hanami 2.2.0.beta1 → 2.2.0.beta2

data/lib/hanami/providers/db.rb

@@ -2,31 +2,37 @@
 
 require "dry/configurable"
 require "dry/core"
+require "uri"
+require_relative "../constants"
 
 module Hanami
   module Providers
     # @api private
     # @since 2.2.0
-    class DB < Dry::System::Provider::Source
+    class DB < Hanami::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"
+      setting :gateways, default: {}
 
       def initialize(...)
         super(...)
 
-        @configured_for_database = false
+        @config_finalized = false
       end
 
       def finalize_config
-        apply_parent_config and return if apply_parent_config?
+        return if @config_finalized
 
-        configure_for_database
+        apply_parent_config if apply_parent_config?
+
+        configure_gateways
+
+        @config_finalized = true
+
+        self
       end
 
       def prepare
@@ -38,59 +44,43 @@ module Hanami
 
         require "hanami-db"
 
-        unless database_url
-          raise Hanami::ComponentLoadError, "A database_url is required to start :db."
-        end
+        gateways = prepare_gateways
 
-        # 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
-          )
-        }
+        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(gateway)
+        @rom_config = ROM::Configuration.new(gateways)
 
-        config.each_plugin do |plugin_spec, config_block|
+        config.each_plugin do |adapter_name, plugin_spec, config_block|
           if config_block
-            @rom_config.plugin(config.adapter, plugin_spec) do |plugin_config|
+            @rom_config.plugin(adapter_name, plugin_spec) do |plugin_config|
               instance_exec(plugin_config, &config_block)
             end
           else
-            @rom_config.plugin(config.adapter, plugin_spec)
+            @rom_config.plugin(adapter_name, 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
+        slice.app.start :db_logging
 
-        # TODO: register mappers & commands
+        # 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)
 
@@ -98,19 +88,14 @@ module Hanami
       end
 
       def stop
-        target["db.rom"].disconnect
+        slice["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
+      # @since 2.2.0
+      def database_urls
+        finalize_config
+        config.gateways.transform_values { _1.database_url }
       end
 
       private
@@ -118,7 +103,7 @@ module Hanami
       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]
+        @parent_db_provider = slice.parent && slice.parent.container.providers[:db]
       end
 
       def apply_parent_config
@@ -128,6 +113,9 @@ module Hanami
           # 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
 
@@ -146,36 +134,29 @@ module Hanami
       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
+        slice.config.db.configure_from_parent && parent_db_provider
       end
 
       def import_from_parent?
-        target.config.db.import_from_parent && target.parent
+        slice.config.db.import_from_parent && slice.parent
       end
 
       def prepare_and_import_parent_db
         return unless parent_db_provider
 
-        target.parent.prepare :db
-        @rom_config = target.parent["db.config"]
+        slice.parent.prepare :db
+        @rom_config = slice.parent["db.config"]
 
-        register "config", (@rom_config = target.parent["db.config"])
-        register "gateway", target.parent["db.gateway"]
+        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
 
-        target.parent.start :db
+        slice.parent.start :db
 
-        register "rom", target.parent["db.rom"]
+        register "rom", slice.parent["db.rom"]
       end
 
       # ROM 5.3 doesn't have a configurable inflector.
@@ -191,6 +172,120 @@ module Hanami
           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(

data/lib/hanami/providers/db_logging.rb

@@ -4,18 +4,18 @@ module Hanami
   module Providers
     # @api private
     # @since 2.2.0
-    class DBLogging < Dry::System::Provider::Source
+    class DBLogging < Hanami::Provider::Source
       # @api private
       # @since 2.2.0
       def prepare
         require "dry/monitor/sql/logger"
-        target["notifications"].register_event :sql
+        slice["notifications"].register_event :sql
       end
 
       # @api private
       # @since 2.2.0
       def start
-        Dry::Monitor::SQL::Logger.new(target["logger"]).subscribe(target["notifications"])
+        Dry::Monitor::SQL::Logger.new(slice["logger"]).subscribe(slice["notifications"])
       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.container.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

@@ -4,11 +4,11 @@ module Hanami
   module Providers
     # @api private
     # @since 2.2.0
-    class Relations < Dry::System::Provider::Source
+    class Relations < Hanami::Provider::Source
       def start
-        start_and_import_parent_relations and return if target.parent && target.config.db.import_from_parent
+        start_and_import_parent_relations and return if slice.parent && slice.config.db.import_from_parent
 
-        target.start :db
+        slice.start :db
 
         register_relations target["db.rom"]
       end
@@ -22,9 +22,9 @@ module Hanami
       end
 
       def start_and_import_parent_relations
-        target.parent.start :relations
+        slice.parent.start :relations
 
-        register_relations target.parent["db.rom"]
+        register_relations slice.parent["db.rom"]
       end
     end
   end

data/lib/hanami/providers/routes.rb

@@ -9,7 +9,7 @@ module Hanami
     #
     # @api private
     # @since 2.0.0
-    class Routes < Dry::System::Provider::Source
+    class Routes < Hanami::Provider::Source
       # @api private
       def prepare
         require "hanami/slice/routes_helper"
@@ -21,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(target.router)
+          Hanami::Slice::RoutesHelper.new(slice.router)
         end
       end
     end

data/lib/hanami/version.rb

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

data/spec/integration/db/commands_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+RSpec.describe "DB / Commands", :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 "registers custom commands" do
+    with_tmp_directory(@dir = Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+            config.logger.stream = File::NULL
+          end
+        end
+      RUBY
+
+      write "app/relations/posts.rb", <<~RUBY
+        module TestApp
+          module Relations
+            class Posts < Hanami::DB::Relation
+              schema :posts, infer: true
+            end
+          end
+        end
+      RUBY
+
+      write "app/db/commands/nested/create_post_with_default_title.rb", <<~RUBY
+        module TestApp
+          module DB
+            module Commands
+              module Nested
+                class CreatePostWithDefaultTitle < ROM::SQL::Commands::Create
+                  relation :posts
+                  register_as :create_with_default_title
+                  result :one
+
+                  before :set_title
+
+                  def set_title(tuple, *)
+                    tuple[:title] ||= "Default title from command"
+                    tuple
+                  end
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
+      ENV["DATABASE_URL"] = "sqlite::memory"
+
+      require "hanami/prepare"
+
+      Hanami.app.prepare :db
+
+      # Manually run a migration and add a test record
+      gateway = TestApp::App["db.gateway"]
+      migration = gateway.migration do
+        change do
+          create_table :posts do
+            primary_key :id
+            column :title, :text, null: false
+          end
+        end
+      end
+      migration.apply(gateway, :up)
+
+      post = TestApp::App["relations.posts"].command(:create_with_default_title).call({})
+      expect(post[:title]).to eq "Default title from command"
+    end
+  end
+end

data/spec/integration/db/db_slices_spec.rb

@@ -84,13 +84,9 @@ RSpec.describe "DB / Slices", :app_integration do
         end
       RUBY
 
-      write "config/db/.keep", ""
-
       write "config/providers/db.rb", <<~RUBY
         Hanami.app.configure_provider :db do
           config.adapter :sql do |a|
-            # a.skip_defaults
-            # a.plugin relation: :auto_restrictions
             a.extension :exclude_or_null
           end
         end
@@ -119,6 +115,7 @@ RSpec.describe "DB / Slices", :app_integration do
       write "slices/main/config/providers/db.rb", <<~RUBY
         Main::Slice.configure_provider :db do
           config.adapter :sql do |a|
+            a.skip_defaults :extensions
             a.extensions.clear
           end
         end
@@ -136,6 +133,9 @@ RSpec.describe "DB / Slices", :app_integration do
 
       ENV["DATABASE_URL"] = "sqlite://" + Pathname(@dir).realpath.join("database.db").to_s
 
+      # Extra gateway for app only. Unlike other config, not copied to child slices.
+      ENV["DATABASE_URL__EXTRA"] = "sqlite://" + Pathname(@dir).realpath.join("extra.db").to_s
+
       require "hanami/prepare"
 
       Main::Slice.prepare :db
@@ -167,6 +167,11 @@ RSpec.describe "DB / Slices", :app_integration do
       migration.apply(gateway, :up)
       gateway.connection.execute("INSERT INTO posts (title) VALUES ('Together breakfast')")
 
+      # Gateways on app are not passed down to child slices
+      expect(Hanami.app["db.rom"].gateways.keys).to eq [:default, :extra]
+      expect(Main::Slice["db.rom"].gateways.keys).to eq [:default]
+      expect(Admin::Slice["db.rom"].gateways.keys).to eq [:default]
+
       # Admin slice has appropriate relations registered, and can access data
       expect(Admin::Slice["db.rom"].relations[:posts].to_a).to eq [{id: 1, title: "Together breakfast"}]
       expect(Admin::Slice["relations.posts"]).to be Admin::Slice["db.rom"].relations[:posts]

data/spec/integration/db/db_spec.rb

@@ -39,6 +39,7 @@ RSpec.describe "DB", :app_integration do
 
       expect(Hanami.app["db.config"]).to be_an_instance_of ROM::Configuration
       expect(Hanami.app["db.gateway"]).to be_an_instance_of ROM::SQL::Gateway
+      expect(Hanami.app["db.gateways.default"]).to be Hanami.app["db.gateway"]
 
       # Manually run a migration and add a test record
       gateway = Hanami.app["db.gateway"]
@@ -90,6 +91,7 @@ RSpec.describe "DB", :app_integration do
 
       expect(Hanami.app["db.config"]).to be_an_instance_of ROM::Configuration
       expect(Hanami.app["db.gateway"]).to be_an_instance_of ROM::SQL::Gateway
+      expect(Hanami.app["db.gateways.default"]).to be Hanami.app["db.gateway"]
 
       # Manually run a migration and add a test record
       gateway = Hanami.app["db.gateway"]
@@ -117,8 +119,6 @@ RSpec.describe "DB", :app_integration do
 
         module TestApp
           class App < Hanami::App
-            config.inflections do |inflections|
-            end
           end
         end
       RUBY
@@ -131,6 +131,32 @@ RSpec.describe "DB", :app_integration do
     end
   end
 
+  it "raises an error when the database driver gem is missing" do
+    allow(Hanami).to receive(:bundled?).and_call_original
+    expect(Hanami).to receive(:bundled?).with("pg").and_return false
+
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "app/relations/.keep", ""
+
+      ENV["DATABASE_URL"] = "postgres://127.0.0.0"
+
+      require "hanami/prepare"
+
+      expect { Hanami.app.prepare :db }.to raise_error(Hanami::ComponentLoadError) { |error|
+        expect(error.message).to include %(The "pg" gem is required)
+      }
+    end
+  end
+
   it "allows the user to configure the provider" do
     with_tmp_directory(Dir.mktmpdir) do
       write "config/app.rb", <<~RUBY
@@ -154,11 +180,10 @@ RSpec.describe "DB", :app_integration do
 
       write "config/providers/db.rb", <<~RUBY
         Hanami.app.configure_provider :db do
-          configure do |config|
-            # In this test, we're not setting an ENV["DATABASE_URL"], and instead configuring
-            # it via the provider source config, to prove that this works
-
-            config.database_url = "sqlite::memory"
+          # In this test, we're not setting an ENV["DATABASE_URL"], and instead configuring
+          # it via the provider source config, to prove that this works
+          config.gateway :default do |gw|
+            gw.database_url = "sqlite::memory"
           end
         end
       RUBY