hanami 2.1.1 → 2.2.0.beta2

data/lib/hanami/providers/db/config.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "dry/core"
+
+module Hanami
+  module Providers
+    class DB < Hanami::Provider::Source
+      # @api public
+      # @since 2.2.0
+      class Config < Dry::Configurable::Config
+        include Dry::Core::Constants
+
+        # @api public
+        # @since 2.2.0
+        def gateway(key)
+          gateway = (gateways[key] ||= Gateway.new)
+          yield gateway if block_given?
+          gateway
+        end
+
+        # @api public
+        # @since 2.2.0
+        def adapter_name
+          self[:adapter]
+        end
+
+        # @api public
+        # @since 2.2.0
+        def adapter(name = Undefined)
+          return adapter_name if name.eql?(Undefined)
+
+          adapter = (adapters[name] ||= Adapter.new)
+          yield adapter if block_given?
+          adapter
+        end
+
+        # @api public
+        # @since 2.2.0
+        def any_adapter
+          adapter = (adapters[nil] ||= Adapter.new)
+          yield adapter if block_given?
+          adapter
+        end
+
+        # @api private
+        def each_plugin
+          return to_enum(__method__) unless block_given?
+
+          universal_plugins = adapters[nil].plugins
+
+          gateways.values.group_by(&:adapter_name).each do |adapter_name, adapter_gateways|
+            per_adapter_plugins = adapter_gateways.map { _1.adapter.plugins }.flatten(1)
+
+            (universal_plugins + per_adapter_plugins).uniq.each do |plugin_spec, config_block|
+              yield adapter_name, plugin_spec, config_block
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/providers/db/gateway.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require "dry/core"
+
+module Hanami
+  module Providers
+    class DB < Hanami::Provider::Source
+      # @api public
+      # @since 2.2.0
+      class Gateway
+        include Dry::Core::Constants
+        include Dry::Configurable
+
+        setting :database_url
+        setting :adapter_name, default: :sql
+        setting :adapter, mutable: true
+
+        # @api public
+        # @since 2.2.0
+        def adapter(name = Undefined)
+          return config.adapter if name.eql?(Undefined)
+
+          if block_given?
+            # If a block is given, explicitly configure the gateway's adapter
+            config.adapter_name = name
+            adapter = (config.adapter ||= Adapters.new_adapter(name))
+            yield adapter
+            adapter
+          else
+            # If an adapter name is given without a block, use the default adapter configured with
+            # the same name
+            config.adapter_name = adapter_name
+          end
+        end
+
+        # @api private
+        def configure_adapter(default_adapters)
+          default_adapter = default_adapters[config.adapter_name]
+          config.adapter ||= default_adapter.dup
+
+          config.adapter.configure_from_adapter(default_adapter)
+          config.adapter.configure_from_adapter(default_adapters[nil])
+          config.adapter.configure_for_database(config.database_url)
+
+          self
+        end
+
+        # @api private
+        def cache_keys
+          [config.database_url, config.adapter.gateway_cache_keys]
+        end
+
+        private
+
+        def method_missing(name, *args, &block)
+          if config.respond_to?(name)
+            config.public_send(name, *args, &block)
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(name, _include_all = false)
+          config.respond_to?(name) || super
+        end
+      end
+    end
+  end
+end

data/lib/hanami/providers/db/sql_adapter.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Providers
+    class DB < Hanami::Provider::Source
+      # @api public
+      # @since 2.2.0
+      class SQLAdapter < Adapter
+        # @api public
+        # @since 2.2.0
+        setting :extensions, mutable: true
+
+        # @api public
+        # @since 2.2.0
+        def extension(*extensions)
+          self.extensions.concat(extensions)
+        end
+
+        # @api public
+        # @since 2.2.0
+        def extensions
+          config.extensions ||= []
+        end
+
+        # @api private
+        def configure_from_adapter(other_adapter)
+          super
+
+          return if skip_defaults?
+
+          # As part of gateway configuration, every gateway will receive the "any adapter" here,
+          # which is a plain `Adapter`, not an `SQLAdapter`. Its configuration will have been merged
+          # by `super`, so no further work is required.
+          return unless other_adapter.is_a?(self.class)
+
+          extensions.concat(other_adapter.extensions).uniq! unless skip_defaults?(:extensions)
+        end
+
+        # @api private
+        def configure_for_database(database_url)
+          return if skip_defaults?
+
+          configure_plugins
+          configure_extensions(database_url)
+        end
+
+        # @api private
+        private def configure_plugins
+          return if skip_defaults?(:plugins)
+
+          # Configure the plugin via a frozen proc, so it can be properly uniq'ed when configured
+          # for multiple gateways. See `Hanami::Providers::DB::Config#each_plugin`.
+          plugin(relations: :instrumentation, &INSTRUMENTATION_PLUGIN_CONFIG)
+
+          plugin relations: :auto_restrictions
+        end
+
+        # @api private
+        INSTRUMENTATION_PLUGIN_CONFIG = -> plugin {
+          plugin.notifications = target["notifications"]
+        }.freeze
+        private_constant :INSTRUMENTATION_PLUGIN_CONFIG
+
+        # @api private
+        private def configure_extensions(database_url)
+          return if skip_defaults?(:extensions)
+
+          # Extensions for all SQL databases
+          extension(
+            :caller_logging,
+            :error_sql,
+            :sql_comments
+          )
+
+          # Extensions for specific databases
+          if database_url.to_s.start_with?(%r{postgres(ql)*://}) # FIXME: what is the canonical postgres URL?
+            extension(
+              :pg_array,
+              :pg_enum,
+              :pg_json,
+              :pg_range
+            )
+          end
+        end
+
+        # @api private
+        def gateway_options
+          {extensions: config.extensions}
+        end
+
+        # @api public
+        # @since 2.2.0
+        def clear
+          config.extensions = nil
+          super
+        end
+      end
+    end
+  end
+end

data/lib/hanami/providers/db.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require "dry/core"
+require "uri"
+require_relative "../constants"
+
+module Hanami
+  module Providers
+    # @api private
+    # @since 2.2.0
+    class DB < Hanami::Provider::Source
+      extend Dry::Core::Cache
+
+      include Dry::Configurable(config_class: Providers::DB::Config)
+
+      setting :adapters, mutable: true, default: Adapters.new
+      setting :gateways, default: {}
+
+      def initialize(...)
+        super(...)
+
+        @config_finalized = false
+      end
+
+      def finalize_config
+        return if @config_finalized
+
+        apply_parent_config if apply_parent_config?
+
+        configure_gateways
+
+        @config_finalized = true
+
+        self
+      end
+
+      def prepare
+        prepare_and_import_parent_db and return if import_from_parent?
+
+        override_rom_inflector
+
+        finalize_config
+
+        require "hanami-db"
+
+        gateways = prepare_gateways
+
+        if gateways[:default]
+          register "gateway", gateways[:default]
+        elsif gateways.length == 1
+          register "gateway", gateways.values.first
+        end
+        gateways.each do |key, gateway|
+          register "gateways.#{key}", gateway
+        end
+
+        @rom_config = ROM::Configuration.new(gateways)
+
+        config.each_plugin do |adapter_name, plugin_spec, config_block|
+          if config_block
+            @rom_config.plugin(adapter_name, plugin_spec) do |plugin_config|
+              instance_exec(plugin_config, &config_block)
+            end
+          else
+            @rom_config.plugin(adapter_name, plugin_spec)
+          end
+        end
+
+        register "config", @rom_config
+      end
+
+      def start
+        start_and_import_parent_db and return if import_from_parent?
+
+        # Set up DB logging for the whole app. We share the app's notifications bus across all
+        # slices, so we only need to configure the subsciprtion for DB logging just once.
+        slice.app.start :db_logging
+
+        # Register ROM components
+        register_rom_components :relation, "relations"
+        register_rom_components :command, File.join("db", "commands")
+        register_rom_components :mapper, File.join("db", "mappers")
+
+        rom = ROM.container(@rom_config)
+
+        register "rom", rom
+      end
+
+      def stop
+        slice["db.rom"].disconnect
+      end
+
+      # @api private
+      # @since 2.2.0
+      def database_urls
+        finalize_config
+        config.gateways.transform_values { _1.database_url }
+      end
+
+      private
+
+      def parent_db_provider
+        return @parent_db_provider if instance_variable_defined?(:@parent_db_provider)
+
+        @parent_db_provider = slice.parent && slice.parent.container.providers[:db]
+      end
+
+      def apply_parent_config
+        parent_db_provider.source.finalize_config
+
+        self.class.settings.keys.each do |key|
+          # Preserve settings already configured locally
+          next if config.configured?(key)
+
+          # Do not copy gateways, these are always configured per slice
+          next if key == :gateways
+
+          # Skip adapter config, we handle this below
+          next if key == :adapters
+
+          config[key] = parent_db_provider.source.config[key]
+        end
+
+        parent_db_provider.source.config.adapters.each do |adapter_name, parent_adapter|
+          adapter = config.adapters[adapter_name]
+
+          adapter.class.settings.keys.each do |key|
+            next if adapter.config.configured?(key)
+
+            adapter.config[key] = parent_adapter.config[key]
+          end
+        end
+      end
+
+      def apply_parent_config?
+        slice.config.db.configure_from_parent && parent_db_provider
+      end
+
+      def import_from_parent?
+        slice.config.db.import_from_parent && slice.parent
+      end
+
+      def prepare_and_import_parent_db
+        return unless parent_db_provider
+
+        slice.parent.prepare :db
+        @rom_config = slice.parent["db.config"]
+
+        register "config", (@rom_config = slice.parent["db.config"])
+        register "gateway", slice.parent["db.gateway"]
+      end
+
+      def start_and_import_parent_db
+        return unless parent_db_provider
+
+        slice.parent.start :db
+
+        register "rom", slice.parent["db.rom"]
+      end
+
+      # ROM 5.3 doesn't have a configurable inflector.
+      #
+      # This is a problem in Hanami because using different
+      # inflection rules for ROM will lead to constant loading
+      # errors.
+      def override_rom_inflector
+        return if ROM::Inflector == Hanami.app["inflector"]
+
+        ROM.instance_eval {
+          remove_const :Inflector
+          const_set :Inflector, Hanami.app["inflector"]
+        }
+      end
+
+      def configure_gateways
+        # Create gateway configs for gateways detected from database_url ENV vars
+        database_urls_from_env = detect_database_urls_from_env
+        database_urls_from_env.keys.each do |key|
+          config.gateways[key] ||= Gateway.new
+        end
+
+        # Create a single default gateway if none is configured or detected from database URLs
+        config.gateways[:default] = Gateway.new if config.gateways.empty?
+
+        # Leave gateways in a stable order: :default first, followed by others in sort order
+        if config.gateways.length > 1
+          gateways = config.gateways
+          config.gateways = {default: gateways[:default], **gateways.sort.to_h}.compact
+        end
+
+        config.gateways.each do |key, gw_config|
+          gw_config.database_url ||= database_urls_from_env.fetch(key) {
+            raise Hanami::ComponentLoadError, "A database_url for gateway #{key} is required to start :db."
+          }
+
+          ensure_database_gem(gw_config.database_url)
+
+          gw_config.configure_adapter(config.adapters)
+        end
+      end
+
+      def prepare_gateways
+        config.gateways.transform_values { |gw_config|
+          # Avoid spurious connections by reusing identically configured gateways across slices
+          gateway = fetch_or_store(gw_config.cache_keys) {
+            ROM::Gateway.setup(
+              gw_config.adapter_name,
+              gw_config.database_url,
+              **gw_config.adapter.gateway_options
+            )
+          }
+        }
+      end
+
+      def detect_database_urls_from_env
+        database_urls = {}
+
+        env_var_prefix = slice.slice_name.name.gsub("/", "__").upcase + "__" unless slice.app?
+
+        # Build gateway URLs from ENV vars with specific gateway named suffixes
+        gateway_prefix = "#{env_var_prefix}DATABASE_URL__"
+        ENV.select { |(k, _)| k.start_with?(gateway_prefix) }
+          .each do |(var, _)|
+            gateway_name = var.split(gateway_prefix).last.downcase
+
+            database_urls[gateway_name.to_sym] = ENV[var]
+          end
+
+        # Set the default gateway from ENV var without suffix
+        if !database_urls.key?(:default)
+          fallback_vars = ["#{env_var_prefix}DATABASE_URL", "DATABASE_URL"].uniq
+
+          fallback_vars.each do |var|
+            url = ENV[var]
+            database_urls[:default] = url and break if url
+          end
+        end
+
+        if Hanami.env?(:test)
+          database_urls.transform_values! { Hanami::DB::Testing.database_url(_1) }
+        end
+
+        database_urls
+      end
+
+      # @api private
+      # @since 2.2.0
+      DATABASE_GEMS = {
+        "mysql2" => "mysql2",
+        "postgres" => "pg",
+        "sqlite" => "sqlite3"
+      }.freeze
+      private_constant :DATABASE_GEMS
+
+      # Raises an error if the relevant database gem for the configured database_url is not
+      # installed.
+      #
+      # Takes a conservative approach to raising errors. It only does so for the database_url
+      # schemes generated by the `hanami new` CLI command. Uknown schemes are ignored and no errors
+      # are raised.
+      def ensure_database_gem(database_url)
+        scheme = URI(database_url).scheme
+        return unless scheme
+
+        database_gem = DATABASE_GEMS[scheme]
+        return unless database_gem
+
+        return if Hanami.bundled?(database_gem)
+
+        raise Hanami::ComponentLoadError, %(The "#{database_gem}" gem is required to connect to #{database_url}. Please add it to your Gemfile.)
+      end
+
+      def register_rom_components(component_type, path)
+        components_path = target.source_path.join(path)
+        components_path.glob("**/*.rb").each do |component_file|
+          component_name = component_file
+            .relative_path_from(components_path)
+            .sub(RB_EXT_REGEXP, "")
+            .to_s
+
+          component_class = target.inflector.camelize(
+            "#{target.slice_name.name}/#{path}/#{component_name}"
+          ).then { target.inflector.constantize(_1) }
+
+          @rom_config.public_send(:"register_#{component_type}", component_class)
+        end
+      end
+    end
+
+    Dry::System.register_provider_source(
+      :db,
+      source: DB,
+      group: :hanami,
+      provider_options: {namespace: true}
+    )
+  end
+end

data/lib/hanami/providers/db_logging.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Providers
+    # @api private
+    # @since 2.2.0
+    class DBLogging < Hanami::Provider::Source
+      # @api private
+      # @since 2.2.0
+      def prepare
+        require "dry/monitor/sql/logger"
+        slice["notifications"].register_event :sql
+      end
+
+      # @api private
+      # @since 2.2.0
+      def start
+        Dry::Monitor::SQL::Logger.new(slice["logger"]).subscribe(slice["notifications"])
+      end
+    end
+  end
+end

data/lib/hanami/providers/inflector.rb

@@ -7,7 +7,7 @@ module Hanami
     #
     # @api private
     # @since 2.0.0
-    class Inflector < Dry::System::Provider::Source
+    class Inflector < Hanami::Provider::Source
       # @api private
       def start
         register :inflector, Hanami.app.inflector

data/lib/hanami/providers/logger.rb

@@ -9,7 +9,7 @@ module Hanami
     #
     # @api private
     # @since 2.0.0
-    class Logger < Dry::System::Provider::Source
+    class Logger < Hanami::Provider::Source
       # @api private
       def start
         register :logger, Hanami.app.config.logger_instance

data/lib/hanami/providers/rack.rb

@@ -12,7 +12,7 @@ module Hanami
     #
     # @api private
     # @since 2.0.0
-    class Rack < Dry::System::Provider::Source
+    class Rack < Hanami::Provider::Source
       # @api private
       def prepare
         Dry::Monitor.load_extensions(:rack)
@@ -30,14 +30,14 @@ module Hanami
 
       # @api private
       def start
-        target.start :logger
+        slice.start :logger
 
         monitor_middleware = Dry::Monitor::Rack::Middleware.new(
           target["notifications"],
           clock: Dry::Monitor::Clock.new(unit: :microsecond)
         )
 
-        rack_logger = Hanami::Web::RackLogger.new(target[:logger], env: target.env)
+        rack_logger = Hanami::Web::RackLogger.new(target[:logger], env: slice.container.env)
         rack_logger.attach(monitor_middleware)
 
         register "monitor", monitor_middleware

data/lib/hanami/providers/relations.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Providers
+    # @api private
+    # @since 2.2.0
+    class Relations < Hanami::Provider::Source
+      def start
+        start_and_import_parent_relations and return if slice.parent && slice.config.db.import_from_parent
+
+        slice.start :db
+
+        register_relations target["db.rom"]
+      end
+
+      private
+
+      def register_relations(rom)
+        rom.relations.each do |name, _|
+          register name, rom.relations[name]
+        end
+      end
+
+      def start_and_import_parent_relations
+        slice.parent.start :relations
+
+        register_relations slice.parent["db.rom"]
+      end
+    end
+  end
+end

data/lib/hanami/providers/routes.rb

@@ -9,19 +9,7 @@ module Hanami
     #
     # @api private
     # @since 2.0.0
-    class Routes < Dry::System::Provider::Source
-      # @api private
-      def self.for_slice(slice)
-        Class.new(self) do |klass|
-          klass.instance_variable_set(:@slice, slice)
-        end
-      end
-
-      # @api private
-      def self.slice
-        @slice || Hanami.app
-      end
-
+    class Routes < Hanami::Provider::Source
       # @api private
       def prepare
         require "hanami/slice/routes_helper"
@@ -33,7 +21,7 @@ module Hanami
         # router during the process of booting. This ensures the router's resolver can run strict
         # action key checks once when it runs on a fully booted slice.
         register :routes do
-          Hanami::Slice::RoutesHelper.new(self.class.slice.router)
+          Hanami::Slice::RoutesHelper.new(slice.router)
         end
       end
     end

data/lib/hanami/rake_tasks.rb

@@ -33,13 +33,14 @@ Hanami::CLI::RakeTasks.register_tasks do
   #
   # If you're not in control and your deployment requires these "standard"
   # Rake tasks, they are here only to solve this specific problem.
-  #
-  # namespace :db do
-  #   task :migrate do
-  #     # TODO(@jodosha): Enable when we'll integrate with ROM
-  #     # run_hanami_command("db migrate")
-  #   end
-  # end
+
+  if Hanami.bundled?("hanami-db")
+    namespace :db do
+      task :migrate do
+        Hanami::CLI::Commands::App::DB::Migrate.new.call
+      end
+    end
+  end
 
   if Hanami.bundled?("hanami-assets")
     namespace :assets do