hanami 2.1.1 → 2.2.0.beta1

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Providers
+    class DB < Dry::System::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_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)
+
+          plugin relations: :instrumentation do |plugin|
+            plugin.notifications = target["notifications"]
+          end
+
+          plugin relations: :auto_restrictions
+        end
+
+        # @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?("postgresql://")
+            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,203 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require "dry/core"
+
+module Hanami
+  module Providers
+    # @api private
+    # @since 2.2.0
+    class DB < Dry::System::Provider::Source
+      extend Dry::Core::Cache
+
+      include Dry::Configurable(config_class: Providers::DB::Config)
+
+      setting :database_url
+      setting :adapter, default: :sql
+      setting :adapters, mutable: true, default: Adapters.new
+      setting :relations_path, default: "relations"
+
+      def initialize(...)
+        super(...)
+
+        @configured_for_database = false
+      end
+
+      def finalize_config
+        apply_parent_config and return if apply_parent_config?
+
+        configure_for_database
+      end
+
+      def prepare
+        prepare_and_import_parent_db and return if import_from_parent?
+
+        override_rom_inflector
+
+        finalize_config
+
+        require "hanami-db"
+
+        unless database_url
+          raise Hanami::ComponentLoadError, "A database_url is required to start :db."
+        end
+
+        # Avoid making spurious connections by reusing identically configured gateways across slices
+        gateway = fetch_or_store(database_url, config.gateway_cache_keys) {
+          ROM::Gateway.setup(
+            config.adapter,
+            database_url,
+            **config.gateway_options
+          )
+        }
+
+        @rom_config = ROM::Configuration.new(gateway)
+
+        config.each_plugin do |plugin_spec, config_block|
+          if config_block
+            @rom_config.plugin(config.adapter, plugin_spec) do |plugin_config|
+              instance_exec(plugin_config, &config_block)
+            end
+          else
+            @rom_config.plugin(config.adapter, plugin_spec)
+          end
+        end
+
+        register "config", @rom_config
+        register "gateway", gateway
+      end
+
+      # @api private
+      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.
+        target.app.start :db_logging
+
+        # Find and register relations
+        relations_path = target.source_path.join(config.relations_path)
+        relations_path.glob("*.rb").each do |relation_file|
+          relation_name = relation_file
+            .relative_path_from(relations_path)
+            .basename(relation_file.extname)
+            .to_s
+
+          relation_class = target.namespace
+            .const_get(:Relations) # TODO don't hardcode
+            .const_get(target.inflector.camelize(relation_name))
+
+          @rom_config.register_relation(relation_class)
+        end
+
+        # TODO: register mappers & commands
+
+        rom = ROM.container(@rom_config)
+
+        register "rom", rom
+      end
+
+      def stop
+        target["db.rom"].disconnect
+      end
+
+      # @api private
+      def database_url
+        return @database_url if instance_variable_defined?(:@database_url)
+
+        # For "main" slice, expect MAIN__DATABASE_URL
+        slice_url_var = "#{target.slice_name.name.gsub("/", "__").upcase}__DATABASE_URL"
+        chosen_url = config.database_url || ENV[slice_url_var] || ENV["DATABASE_URL"]
+        chosen_url &&= Hanami::DB::Testing.database_url(chosen_url) if Hanami.env?(:test)
+
+        @database_url = chosen_url
+      end
+
+      private
+
+      def parent_db_provider
+        return @parent_db_provider if instance_variable_defined?(:@parent_db_provider)
+
+        @parent_db_provider = target.parent && target.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)
+
+          # 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?
+        target.config.db.configure_from_parent && parent_db_provider
+      end
+
+      def configure_for_database
+        return if @configured_for_database
+
+        config.adapter(config.adapter_name).configure_for_database(database_url)
+        @configured_for_database = true
+      end
+
+      def import_from_parent?
+        target.config.db.import_from_parent && target.parent
+      end
+
+      def prepare_and_import_parent_db
+        return unless parent_db_provider
+
+        target.parent.prepare :db
+        @rom_config = target.parent["db.config"]
+
+        register "config", (@rom_config = target.parent["db.config"])
+        register "gateway", target.parent["db.gateway"]
+      end
+
+      def start_and_import_parent_db
+        return unless parent_db_provider
+
+        target.parent.start :db
+
+        register "rom", target.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
+    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 < Dry::System::Provider::Source
+      # @api private
+      # @since 2.2.0
+      def prepare
+        require "dry/monitor/sql/logger"
+        target["notifications"].register_event :sql
+      end
+
+      # @api private
+      # @since 2.2.0
+      def start
+        Dry::Monitor::SQL::Logger.new(target["logger"]).subscribe(target["notifications"])
+      end
+    end
+  end
+end

data/lib/hanami/providers/rack.rb

@@ -37,7 +37,7 @@ module Hanami
           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: target.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 < Dry::System::Provider::Source
+      def start
+        start_and_import_parent_relations and return if target.parent && target.config.db.import_from_parent
+
+        target.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
+        target.parent.start :relations
+
+        register_relations target.parent["db.rom"]
+      end
+    end
+  end
+end

data/lib/hanami/providers/routes.rb

@@ -10,18 +10,6 @@ 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
-
       # @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(target.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

data/lib/hanami/slice.rb

@@ -101,6 +101,16 @@ module Hanami
         Hanami.app
       end
 
+      # Returns true if the slice is Hanami.app
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      # @since 2.2.0
+      def app?
+        eql?(app)
+      end
+
       # Returns the slice's config.
       #
       # A slice's config is copied from the app config at time of first access.
@@ -203,6 +213,16 @@ module Hanami
         config.root || app.root.join(SLICES_DIR, slice_name.to_s)
       end
 
+      # Returns the slice's root component directory, accounting for App as a special case.
+      #
+      # @return [Pathname]
+      #
+      # @api public
+      # @since 2.2.0
+      def source_path
+        app? ? root.join(APP_DIR) : root
+      end
+
       # Returns the slice's configured inflector.
       #
       # Unless explicitly re-configured for the slice, this will be the app's inflector.
@@ -507,6 +527,12 @@ module Hanami
         container.register_provider(...)
       end
 
+      # @api public
+      # @since 2.1.0
+      def configure_provider(*args, **kwargs, &block)
+        container.register_provider(*args, **kwargs, from: :hanami, &block)
+      end
+
       # @overload start(provider_name)
       #   Starts a provider.
       #
@@ -559,6 +585,13 @@ module Hanami
         container.key?(...)
       end
 
+      # Required for the slice to act as a provider target
+      # @api public
+      # @since 2.2.0
+      def registered?(...)
+        container.registered?(...)
+      end
+
       # Returns an array of keys for all currently registered components in the container.
       #
       # For a prepared slice, this will be the set of components that have been previously resolved.
@@ -842,6 +875,7 @@ module Hanami
       def prepare_container_base_config
         container.config.name = slice_name.to_sym
         container.config.root = root
+        container.config.provider_registrar = ProviderRegistrar.for_slice(self)
         container.config.provider_dirs = [File.join("config", "providers")]
         container.config.registrations_dir = File.join("config", "registrations")
 
@@ -893,12 +927,29 @@ module Hanami
         # point we're still in the process of preparing.
         if routes
           require_relative "providers/routes"
-          register_provider(:routes, source: Providers::Routes.for_slice(self))
+          register_provider(:routes, source: Providers::Routes)
         end
 
         if assets_dir? && Hanami.bundled?("hanami-assets")
           require_relative "providers/assets"
-          register_provider(:assets, source: Providers::Assets.for_slice(self))
+          register_provider(:assets, source: Providers::Assets)
+        end
+
+        if Hanami.bundled?("hanami-db")
+          # Explicit require here to ensure the provider source registers itself, to allow the user
+          # to configure it within their own concrete provider file.
+          require_relative "providers/db"
+
+          if register_db_provider?
+            # Only register providers if the user hasn't provided their own
+            if !container.providers[:db]
+              register_provider(:db, namespace: true, source: Providers::DB)
+            end
+
+            if !container.providers[:relations]
+              register_provider(:relations, namespace: true, source: Providers::Relations)
+            end
+          end
         end
       end
 
@@ -1028,8 +1079,37 @@ module Hanami
       private_constant :ROUTER_NOT_FOUND_HANDLER
 
       def assets_dir?
-        assets_path = app.eql?(self) ? root.join("app", "assets") : root.join("assets")
-        assets_path.directory?
+        source_path.join("assets").directory?
+      end
+
+      def register_db_provider?
+        concrete_db_provider? ||
+          db_config_dir? ||
+          relations_dir? ||
+          db_source_dir? ||
+          import_db_from_parent?
+      end
+
+      def concrete_db_provider?
+        root.join(CONFIG_DIR, "providers", "db.rb").exist?
+      end
+
+      def db_config_dir?
+        root.join("config", "db").directory?
+      end
+
+      def relations_dir?
+        source_path.join("relations").directory?
+      end
+
+      def db_source_dir?
+        source_path.join("db").directory?
+      end
+
+      def import_db_from_parent?
+        parent &&
+          config.db.import_from_parent &&
+          parent.container.providers[:db]
       end
 
       # rubocop:enable Metrics/AbcSize

data/lib/hanami/version.rb

@@ -7,7 +7,7 @@ module Hanami
   # @api private
   module Version
     # @api public
-    VERSION = "2.1.1"
+    VERSION = "2.2.0.beta1"
 
     # @since 0.9.0
     # @api private

data/lib/hanami.rb

@@ -17,6 +17,9 @@ module Hanami
   # @since 2.0.0
   def self.loader
     @loader ||= Zeitwerk::Loader.for_gem.tap do |loader|
+      loader.inflector.inflect "db" => "DB"
+      loader.inflector.inflect "db_logging" => "DBLogging"
+      loader.inflector.inflect "sql_adapter" => "SQLAdapter"
       loader.ignore(
         "#{loader.dirs.first}/hanami/{constants,boot,errors,extensions/router/errors,prepare,rake_tasks,setup}.rb"
       )

data/spec/integration/container/provider_environment_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+RSpec.describe "Container / Provider environment", :app_integration do
+  let!(:app) {
+    module TestApp
+      class App < Hanami::App
+        class << self
+          attr_accessor :test_provider_target
+        end
+      end
+    end
+
+    before_prepare if respond_to?(:before_prepare)
+
+    Hanami.app.prepare
+    Hanami.app
+  }
+
+  context "app provider" do
+    before do
+      Hanami.app.register_provider :test_provider, namespace: true do
+        start do
+          Hanami.app.test_provider_target = target
+        end
+      end
+    end
+
+    it "exposes the app as the provider target" do
+      Hanami.app.start :test_provider
+      expect(Hanami.app.test_provider_target).to be Hanami.app
+    end
+  end
+
+  context "slice provider" do
+    def before_prepare
+      Hanami.app.register_slice :main
+    end
+
+    before do
+      Main::Slice.register_provider :test_provider, namespace: true do
+        start do
+          Hanami.app.test_provider_target = target
+        end
+      end
+    end
+
+    it "exposes the slice as the provider target" do
+      Main::Slice.start :test_provider
+      expect(Hanami.app.test_provider_target).to be Main::Slice
+    end
+  end
+end

data/spec/integration/db/auto_registration_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+RSpec.describe "DB / auto-registration", :app_integration do
+  before do
+    @env = ENV.to_h
+    allow(Hanami::Env).to receive(:loaded?).and_return(false)
+  end
+
+  after do
+    ENV.replace(@env)
+  end
+
+  it "does not auto-register files in entities/, structs/, or db/" do
+    with_tmp_directory(@dir = Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "app/db/changesets/update_posts.rb", ""
+      write "app/entities/post.rb", ""
+      write "app/structs/post.rb", ""
+
+      ENV["DATABASE_URL"] = "sqlite::memory"
+
+      require "hanami/boot"
+
+      expect(Hanami.app.keys).not_to include(*[
+        "db.changesets.update_posts",
+        "entities.post",
+        "structs.post"
+      ])
+    end
+  end
+end