hanami 2.1.0 → 2.2.0.beta1

data/lib/hanami/providers/assets.rb

@@ -10,18 +10,6 @@ module Hanami
     # @api private
     # @since 2.0.0
     class Assets < 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/assets"
@@ -29,18 +17,12 @@ module Hanami
 
       # @api private
       def start
-        root = slice.app.root.join("public", "assets", Hanami::Assets.public_assets_dir(slice).to_s)
+        root = target.app.root.join("public", "assets", Hanami::Assets.public_assets_dir(target).to_s)
 
-        assets = Hanami::Assets.new(config: slice.config.assets, root: root)
+        assets = Hanami::Assets.new(config: target.config.assets, root: root)
 
         register(:assets, assets)
       end
-
-      private
-
-      def slice
-        self.class.slice
-      end
     end
   end
 end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+
+module Hanami
+  module Providers
+    class DB < Dry::System::Provider::Source
+      # @api public
+      # @since 2.2.0
+      class Adapter
+        include Dry::Configurable
+
+        # @api public
+        # @since 2.2.0
+        setting :plugins, mutable: true
+
+        # @api private
+        def initialize(...)
+          @skip_defaults = Hash.new(false)
+        end
+
+        # @api public
+        # @since 2.2.0
+        def skip_defaults(setting_name = nil)
+          @skip_defaults[setting_name] = true
+        end
+
+        # @api private
+        private def skip_defaults?(setting_name = nil)
+          @skip_defaults[setting_name]
+        end
+
+        # @api private
+        def configure_for_database(database_url)
+        end
+
+        # @api public
+        # @since 2.2.0
+        def plugin(**plugin_spec, &config_block)
+          plugins << [plugin_spec, config_block]
+        end
+
+        # @api public
+        # @since 2.2.0
+        def plugins
+          config.plugins ||= []
+        end
+
+        # @api private
+        def gateway_cache_keys
+          gateway_options
+        end
+
+        # @api private
+        def gateway_options
+          {}
+        end
+
+        # @api public
+        # @since 2.2.0
+        def clear
+          config.plugins = nil
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Providers
+    class DB < Dry::System::Provider::Source
+      # @api public
+      # @since 2.2.0
+      class Adapters
+        # @api private
+        # @since 2.2.0
+        ADAPTER_CLASSES = Hash.new(Adapter).update(
+          sql: SQLAdapter
+        ).freeze
+        private_constant :ADAPTER_CLASSES
+
+        extend Forwardable
+
+        def_delegators :adapters, :[], :[]=, :each, :to_h
+
+        # @api private
+        # @since 2.2.0
+        attr_reader :adapters
+
+        # @api private
+        # @since 2.2.0
+        def initialize
+          @adapters = Hash.new do |hsh, key|
+            hsh[key] = ADAPTER_CLASSES[key].new
+          end
+        end
+
+        # @api private
+        # @since 2.2.0
+        def initialize_copy(source)
+          @adapters = source.adapters.dup
+
+          source.adapters.each do |key, val|
+            @adapters[key] = val.dup
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "dry/core"
+
+module Hanami
+  module Providers
+    class DB < Dry::System::Provider::Source
+      # @api public
+      # @since 2.2.0
+      class Config < Dry::Configurable::Config
+        include Dry::Core::Constants
+
+        # @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
+        # @since 2.2.0
+        def gateway_cache_keys
+          adapters[adapter_name].gateway_cache_keys
+        end
+
+        # @api private
+        # @since 2.2.0
+        def gateway_options
+          adapters[adapter_name].gateway_options
+        end
+
+        # @api public
+        # @since 2.2.0
+        def each_plugin
+          universal_plugins = adapters[nil].plugins
+          adapter_plugins = adapters[adapter_name].plugins
+
+          plugins = universal_plugins + adapter_plugins
+
+          return to_enum(__method__) unless block_given?
+
+          plugins.each do |plugin_spec, config_block|
+            yield plugin_spec, config_block
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -20,8 +20,8 @@ module Hanami
         # Explicitly register the Rack middleware events on our notifications bus. The Dry::Monitor
         # rack extension (activated above) does register these globally, but if the notifications
         # bus has been used before this provider loads, then it will have created its own separate
-        # locally copy of all registered events as of that moment in time, which will not included
-        # the Rack events globally reigstered above.
+        # local copy of all registered events as of that moment in time, which will not be included
+        # in the Rack events globally registered above.
         notifications = target["notifications"]
         notifications.register_event(Dry::Monitor::Rack::Middleware::REQUEST_START)
         notifications.register_event(Dry::Monitor::Rack::Middleware::REQUEST_STOP)
@@ -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

@@ -32,14 +32,15 @@ Hanami::CLI::RakeTasks.register_tasks do
   # Please use them when you're in control of your deployment environment.
   #
   # If you're not in control and your deployment requires these "standard"
-  # Rake tasks, they are here to solve this only specific problem.
-  #
-  # namespace :db do
-  #   task :migrate do
-  #     # TODO(@jodosha): Enable when we'll integrate with ROM
-  #     # run_hanami_command("db migrate")
-  #   end
-  # end
+  # Rake tasks, they are here only to solve this specific problem.
+
+  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/settings.rb

@@ -8,7 +8,7 @@ module Hanami
   # Provides user-defined settings for an Hanami app or slice.
   #
   # Define your own settings by inheriting from this class in `config/settings.rb` within an app or
-  # slice. Your settings will be loaded from matching ENV vars (with upper-cased names) and made
+  # slice. Your settings will be loaded from matching ENV vars (with upper-cased names) and be
   # registered as a component as part of the Hanami app {Hanami::Slice::ClassMethods#prepare
   # prepare} step.
   #
@@ -160,8 +160,8 @@ module Hanami
         value = store.fetch(name, Undefined)
 
         if value.eql?(Undefined)
-          # When a key is missing entirely from the store, _read_ its value from the config instead,
-          # which ensures its setting constructor runs (with a `nil` argument given) and raises any
+          # When a key is missing entirely from the store, _read_ its value from the config instead.
+          # This ensures its setting constructor runs (with a `nil` argument given) and raises any
           # necessary errors.
           public_send(name)
         else