lib/hanami/cli/commands/app/db/utils/database.rb in hanami-cli-2.2.0.beta1 vs lib/hanami/cli/commands/app/db/utils/database.rb in hanami-cli-2.2.0.beta2

@@ -9,13 +9,10 @@
         module DB
           module Utils
             # @api private
             # @since 2.2.0
             class Database
-              MIGRATIONS_DIR = "config/db/migrate"
-              private_constant :MIGRATIONS_DIR
-
               DATABASE_CLASS_RESOLVER = Hash.new { |_, key|
                 raise "#{key} is not a supported db scheme"
               }.update(
                 "sqlite" => -> {
                   require_relative("sqlite")
@@ -27,48 +24,61 @@
                 },
                 "postgresql" => -> {
                   require_relative("postgres")
                   Postgres
                 },
-                "mysql" => -> {
+                "mysql2" => -> {
                   require_relative("mysql")
                   Mysql
                 }
               ).freeze
 
-              def self.[](slice, system_call:)
+              def self.database_class(database_url)
+                database_scheme = URI(database_url).scheme
+                DATABASE_CLASS_RESOLVER[database_scheme].call
+              end
+
+              def self.from_slice(slice:, system_call:)
                 provider = slice.container.providers[:db]
-                raise "this is not a db slice" unless provider
+                raise "No :db provider for #{slice}" unless provider
 
-                database_scheme = provider.source.database_url.then { URI(_1).scheme }
-                database_class = DATABASE_CLASS_RESOLVER[database_scheme].call
-                database_class.new(slice: slice, system_call: system_call)
+                provider.source.database_urls.map { |(gateway_name, database_url)|
+                  database = database_class(database_url).new(
+                    slice: slice,
+                    gateway_name: gateway_name,
+                    system_call: system_call
+                  )
+
+                  [gateway_name, database]
+                }.to_h
               end
 
               attr_reader :slice
+              attr_reader :gateway_name
 
               attr_reader :system_call
 
-              def initialize(slice:, system_call:)
+              def initialize(slice:, gateway_name:, system_call:)
                 @slice = slice
+                @gateway_name = gateway_name
                 @system_call = system_call
               end
 
               def name
                 database_uri.path.sub(%r{^/}, "")
               end
 
               def database_url
-                slice.container.providers[:db].source.database_url
+                slice.container.providers[:db].source.database_urls.fetch(gateway_name)
               end
 
               def database_uri
                 @database_uri ||= URI(database_url)
               end
 
               def gateway
-                slice["db.config"].gateways[:default]
+                slice["db.config"].gateways[gateway_name]
               end
 
               def connection
                 gateway.connection
               end
@@ -125,22 +135,42 @@
 
               def applied_migrations
                 sequel_migrator.applied_migrations
               end
 
+              def db_config_path
+                slice.root.join("config", "db")
+              end
+
+              def db_config_dir?
+                db_config_path.directory?
+              end
+
               def migrations_path
-                slice.root.join(MIGRATIONS_DIR)
+                if gateway_name == :default
+                  db_config_path.join("migrate")
+                else
+                  db_config_path.join("#{gateway_name}_migrate")
+                end
               end
 
               def migrations_dir?
                 migrations_path.directory?
               end
 
               def structure_file
-                slice.root.join("config/db/structure.sql")
+                path = slice.root.join("config", "db")
+
+                if gateway_name == :default
+                  path.join("structure.sql")
+                else
+                  path.join("#{gateway_name}_structure.sql")
+                end
               end
 
               def schema_migrations_sql_dump
+                return unless migrations_dir?
+
                 sql = +"INSERT INTO schema_migrations (filename) VALUES\n"
                 sql << applied_migrations.map { |v| "('#{v}')" }.join(",\n")
                 sql << ";"
                 sql
               end