hanami-cli 2.2.0.beta1 → 2.2.0.rc1

data/lib/hanami/cli/commands/app/db/structure/dump.rb

@@ -11,13 +11,15 @@ module Hanami
             class Dump < DB::Command
               desc "Dumps database structure to config/db/structure.sql file"
 
+              option :gateway, required: false, desc: "Use database for gateway"
+
               # @api private
-              def call(app: false, slice: nil, command_exit: method(:exit), **)
+              def call(app: false, slice: nil, gateway: nil, command_exit: method(:exit), **)
                 exit_codes = []
 
-                databases(app: app, slice: slice).each do |database|
-                  structure_path = database.slice.root.join("config", "db", "structure.sql")
-                  relative_structure_path = structure_path.relative_path_from(database.slice.app.root)
+                databases(app: app, slice: slice, gateway: gateway).each do |database|
+                  relative_structure_path = database.structure_file
+                    .relative_path_from(database.slice.app.root)
 
                   measure("#{database.name} structure dumped to #{relative_structure_path}") do
                     catch :dump_failed do
@@ -29,8 +31,11 @@ module Hanami
                         throw :dump_failed, false
                       end
 
-                      File.open(structure_path, "a") do |f|
-                        f.puts "#{database.schema_migrations_sql_dump}\n"
+                      migrations_sql = database.schema_migrations_sql_dump
+                      if migrations_sql
+                        File.open(database.structure_file, "a") do |f|
+                          f.puts "#{migrations_sql}\n"
+                        end
                       end
 
                       true

data/lib/hanami/cli/commands/app/db/structure/load.rb

@@ -14,15 +14,17 @@ module Hanami
 
               desc "Loads database from config/db/structure.sql file"
 
+              option :gateway, required: false, desc: "Use database for gateway"
+
               # @api private
-              def call(app: false, slice: nil, command_exit: method(:exit), **)
+              def call(app: false, slice: nil, gateway: nil, command_exit: method(:exit), **)
                 exit_codes = []
 
-                databases(app: app, slice: slice).each do |database|
-                  structure_path = database.slice.root.join(STRUCTURE_PATH)
-                  next unless structure_path.exist?
+                databases(app: app, slice: slice, gateway: gateway).each do |database|
+                  next unless database.structure_file.exist?
 
-                  relative_structure_path = structure_path.relative_path_from(database.slice.app.root)
+                  relative_structure_path = database.structure_file
+                    .relative_path_from(database.slice.app.root)
 
                   measure("#{database.name} structure loaded from #{relative_structure_path}") do
                     catch :load_failed do
@@ -42,6 +44,8 @@ module Hanami
                 exit_codes.each do |code|
                   break command_exit.(code) if code > 0
                 end
+
+                re_run_development_command_in_test
               end
             end
           end

data/lib/hanami/cli/commands/app/db/utils/database.rb

@@ -11,9 +11,6 @@ module Hanami
             # @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(
@@ -29,27 +26,40 @@ module Hanami
                   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
 
@@ -58,7 +68,7 @@ module Hanami
               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
@@ -66,7 +76,7 @@ module Hanami
               end
 
               def gateway
-                slice["db.config"].gateways[:default]
+                slice["db.config"].gateways[gateway_name]
               end
 
               def connection
@@ -127,8 +137,20 @@ module Hanami
                 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?
@@ -136,10 +158,18 @@ module Hanami
               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 << ";"

data/lib/hanami/cli/commands/app/db/utils/mysql.rb

@@ -11,18 +11,71 @@ module Hanami
             # @api private
             class Mysql < Database
               # @api private
-              def create_command
-                raise Hanami::CLI::NotImplementedError
+              def exec_create_command
+                return true if exists?
+
+                exec_cli("mysql", %(-e "CREATE DATABASE #{escaped_name}"))
+              end
+
+              # @api private
+              # @since 2.2.0
+              def exec_drop_command
+                return true unless exists?
+
+                exec_cli("mysql", %(-e "DROP DATABASE #{escaped_name}"))
+              end
+
+              # @api private
+              # @since 2.2.0
+              def exists?
+                result = exec_cli("mysql", %(-e "SHOW DATABASES LIKE '#{name}'" --batch))
+
+                result.successful? && result.out != ""
               end
 
               # @api private
+              # @since 2.2.0
               def exec_dump_command
-                raise Hanami::CLI::NotImplementedError
+                exec_cli(
+                  "mysqldump",
+                  "--no-data --routines --skip-comments --result-file=#{structure_file} #{escaped_name}"
+                )
               end
 
               # @api private
+              # @since 2.2.0
               def exec_load_command
-                raise Hanami::CLI::NotImplementedError
+                exec_cli(
+                  "mysql",
+                  %(--execute "SET FOREIGN_KEY_CHECKS = 0; SOURCE #{structure_file}; SET FOREIGN_KEY_CHECKS = 1" --database #{escaped_name})
+                )
+              end
+
+              private
+
+              def escaped_name
+                Shellwords.escape(name)
+              end
+
+              def exec_cli(cli_name, cli_args)
+                system_call.call(
+                  "#{cli_name} #{cli_options} #{cli_args}",
+                  env: cli_env_vars
+                )
+              end
+
+              def cli_options
+                [].tap { |opts|
+                  opts << "--host=#{Shellwords.escape(database_uri.host)}" if database_uri.host
+                  opts << "--port=#{Shellwords.escape(database_uri.port)}" if database_uri.port
+                  opts << "--user=#{Shellwords.escape(database_uri.user)}" if database_uri.user
+                }.join(" ")
+              end
+
+              def cli_env_vars
+                @cli_env_vars ||= {}.tap do |vars|
+                  vars["MYSQL_PWD"] = database_uri.password.to_s if database_uri.password
+                end
               end
             end
           end

data/lib/hanami/cli/commands/app/db/utils/postgres.rb

@@ -54,6 +54,19 @@ module Hanami
                 )
               end
 
+              def schema_migrations_sql_dump
+                migrations_sql = super
+                return unless migrations_sql
+                
+                search_path = gateway.connection
+                  .fetch("SHOW search_path").to_a.first
+                  .fetch(:search_path)
+
+                +"SET search_path TO #{search_path};\n\n" << migrations_sql
+              end
+
+              private
+
               def escaped_name
                 Shellwords.escape(name)
               end
@@ -66,14 +79,6 @@ module Hanami
                   vars["PGPASSWORD"] = database_uri.password.to_s if database_uri.password
                 end
               end
-
-              def schema_migrations_sql_dump
-                search_path = slice["db.gateway"].connection
-                  .fetch("SHOW search_path").to_a.first
-                  .fetch(:search_path)
-
-                +"SET search_path TO #{search_path};\n\n" << super
-              end
             end
           end
         end

data/lib/hanami/cli/commands/app/db/version.rb

@@ -9,11 +9,14 @@ module Hanami
           class Version < DB::Command
             desc "Print schema version"
 
+            option :gateway, required: false, desc: "Use database for gateway"
+
             # @api private
-            def call(app: false, slice: nil, **)
-              databases(app: app, slice: slice).each do |database|
+            def call(app: false, slice: nil, gateway: nil, **)
+              databases(app: app, slice: slice, gateway: gateway).each do |database|
                 unless database.migrations_dir?
-                  out.puts "=> Cannot find version for slice #{database.slice.slice_name.to_s.inspect}: missing config/db/migrate/ dir"
+                  relative_migrations_path = database.migrations_path.relative_path_from(database.slice.app.root)
+                  out.puts "=> Cannot find version for database #{database.name}: no migrations directory at #{relative_migrations_path}/"
                   return
                 end
 

data/lib/hanami/cli/commands/app/generate/action.rb

@@ -25,6 +25,9 @@ module Hanami
             DEFAULT_SKIP_TESTS = false
             private_constant :DEFAULT_SKIP_TESTS
 
+            DEFAULT_SKIP_ROUTE = false
+            private_constant :DEFAULT_SKIP_ROUTE
+
             argument :name, required: true, desc: "Action name"
             option :url, required: false, type: :string, desc: "Action URL"
             option :http, required: false, type: :string, desc: "Action HTTP method"
@@ -41,6 +44,12 @@ module Hanami
               type: :flag,
               default: DEFAULT_SKIP_TESTS,
               desc: "Skip test generation"
+            option \
+              :skip_route,
+              required: false,
+              type: :flag,
+              default: DEFAULT_SKIP_ROUTE,
+              desc: "Skip route generation"
             option :slice, required: false, desc: "Slice name"
 
             # rubocop:disable Layout/LineLength
@@ -83,7 +92,8 @@ module Hanami
               http: nil,
               format: DEFAULT_FORMAT,
               skip_view: DEFAULT_SKIP_VIEW,
-              skip_tests: DEFAULT_SKIP_TESTS, # rubocop:disable Lint/UnusedMethodArgument
+              skip_tests: DEFAULT_SKIP_TESTS, # rubocop:disable Lint/UnusedMethodArgument,
+              skip_route: DEFAULT_SKIP_ROUTE,
               slice: nil,
               context: nil,
               **
@@ -96,7 +106,7 @@ module Hanami
                 raise InvalidActionNameError.new(name)
               end
 
-              generator.call(app.namespace, controller, action, url, http, format, skip_view, slice, context: context)
+              generator.call(app.namespace, controller, action, url, http, format, skip_view, skip_route, slice, context: context)
             end
 
             # rubocop:enable Metrics/ParameterLists

data/lib/hanami/cli/commands/app/generate/command.rb

@@ -38,8 +38,19 @@ module Hanami
             # @since 2.2.0
             # @api private
             def call(name:, slice: nil, **)
-              normalized_slice = inflector.underscore(slice) if slice
-              generator.call(app.namespace, name, normalized_slice)
+              if slice
+                generator.call(
+                  key: name,
+                  namespace: slice,
+                  base_path: fs.join("slices", inflector.underscore(slice))
+                )
+              else
+                generator.call(
+                  key: name,
+                  namespace: app.namespace,
+                  base_path: "app"
+                )
+              end
             end
           end
         end

data/lib/hanami/cli/commands/app/generate/migration.rb

@@ -9,16 +9,36 @@ module Hanami
           # @api private
           class Migration < Command
             argument :name, required: true, desc: "Migration name"
+            option :gateway, desc: "Generate migration for gateway"
 
             example [
               %(create_posts),
               %(add_published_at_to_posts),
               %(create_users --slice=admin),
+              %(create_comments --slice=admin --gateway=extra),
             ]
 
             def generator_class
               Generators::App::Migration
             end
+
+            def call(name:, slice: nil, gateway: nil)
+              if slice
+                generator.call(
+                  key: name,
+                  namespace: slice,
+                  base_path: fs.join("slices", inflector.underscore(slice)),
+                  gateway: gateway
+                )
+              else
+                generator.call(
+                  key: name,
+                  namespace: app.namespace,
+                  base_path: "app",
+                  gateway: gateway
+                )
+              end
+            end
           end
         end
       end

data/lib/hanami/cli/commands/app/generate/relation.rb

@@ -21,12 +21,6 @@ module Hanami
             def generator_class
               Generators::App::Relation
             end
-
-            # @since 2.2.0
-            # @api private
-            def call(name:, slice: nil, **opts)
-              super(name: name, slice: slice, **opts)
-            end
           end
         end
       end

data/lib/hanami/cli/commands/app/generate/repo.rb

@@ -30,13 +30,9 @@ module Hanami
 
             # @since 2.2.0
             # @api private
-            def call(name:, slice: nil, **opts)
-              normalized_name = if name.end_with?("_repo")
-                                  name
-                                else
-                                  "#{inflector.singularize(name)}_repo"
-                                end
-              super(name: normalized_name, slice: slice, **opts)
+            def call(name:, **opts)
+              name = "#{inflector.singularize(name)}_repo" unless name.end_with?("_repo")
+              super
             end
           end
         end

data/lib/hanami/cli/commands/app/generate/slice.rb

@@ -21,13 +21,25 @@ module Hanami
             SKIP_DB_DEFAULT = false
             private_constant :SKIP_DB_DEFAULT
 
+            # @since 2.2.0
+            # @api private
+            DEFAULT_SKIP_ROUTE = false
+            private_constant :DEFAULT_SKIP_ROUTE
+
             # @since 2.2.0
             # @api private
             option :skip_db,
-              type: :boolean,
+              type: :flag,
               required: false,
               default: SKIP_DB_DEFAULT,
               desc: "Skip database"
+            # @since 2.2.0
+            # @api private
+            option :skip_route,
+              type: :flag,
+              required: false,
+              default: DEFAULT_SKIP_ROUTE,
+              desc: "Skip route generation"
 
             example [
               "admin          # Admin slice (/admin URL prefix)",
@@ -50,7 +62,8 @@ module Hanami
             def call(
               name:,
               url: nil,
-              skip_db: SKIP_DB_DEFAULT
+              skip_db: SKIP_DB_DEFAULT,
+              skip_route: DEFAULT_SKIP_ROUTE
             )
               require "hanami/setup"
 
@@ -58,7 +71,7 @@ module Hanami
               name = inflector.underscore(Shellwords.shellescape(name))
               url = sanitize_url_prefix(name, url)
 
-              generator.call(app, name, url, skip_db: skip_db)
+              generator.call(app, name, url, skip_db: skip_db, skip_route: skip_route)
             end
 
             private

data/lib/hanami/cli/commands/app.rb

@@ -41,16 +41,28 @@ module Hanami
             end
 
             register "generate", aliases: ["g"] do |prefix|
-              prefix.register "action", Generate::Action
-              prefix.register "component", Generate::Component
-              prefix.register "migration", Generate::Migration
-              prefix.register "operation", Generate::Operation
-              prefix.register "part", Generate::Part
-              prefix.register "relation", Generate::Relation
-              prefix.register "repo", Generate::Repo
               prefix.register "slice", Generate::Slice
-              prefix.register "struct", Generate::Struct
-              prefix.register "view", Generate::View
+              prefix.register "component", Generate::Component
+
+              if Hanami.bundled?("hanami-controller")
+                prefix.register "action", Generate::Action
+              end
+
+              if Hanami.bundled?("dry-operation")
+                prefix.register "operation", Generate::Operation
+              end
+
+              if Hanami.bundled?("hanami-view")
+                prefix.register "view", Generate::View
+                prefix.register "part", Generate::Part
+              end
+
+              if Hanami.bundled?("hanami-db")
+                prefix.register "migration", Generate::Migration
+                prefix.register "relation", Generate::Relation
+                prefix.register "repo", Generate::Repo
+                prefix.register "struct", Generate::Struct
+              end
             end
           end
         end

data/lib/hanami/cli/files.rb

@@ -18,7 +18,11 @@ module Hanami
       # @api private
       def write(path, *content)
         already_exists = exist?(path)
+
         super
+
+        delete_keepfiles(path) unless already_exists
+
         if already_exists
           updated(path)
         else
@@ -46,6 +50,24 @@ module Hanami
 
       attr_reader :out
 
+      # Removes .keep files in any directories leading up to the given path.
+      #
+      # Does not attempt to remove `.keep` files in the following scenarios:
+      #   - When the given path is a `.keep` file itself.
+      #   - When the given path is absolute, since ascending up this path may lead to removal of
+      #     files outside the Hanami project directory.
+      def delete_keepfiles(path)
+        path = Pathname(path)
+
+        return if path.absolute?
+        return if path.relative_path_from(path.dirname).to_s == ".keep"
+
+        path.dirname.ascend do |part|
+          keepfile = (part + ".keep").to_path
+          delete(keepfile) if exist?(keepfile)
+        end
+      end
+
       def updated(path)
         out.puts "Updated #{path}"
       end

data/lib/hanami/cli/generators/app/action.rb

@@ -21,12 +21,12 @@ module Hanami
 
           # @since 2.0.0
           # @api private
-          def call(app, controller, action, url, http, format, skip_view, slice, context: nil)
+          def call(app, controller, action, url, http, format, skip_view, skip_route, slice, context: nil)
             context ||= ActionContext.new(inflector, app, slice, controller, action)
             if slice
-              generate_for_slice(controller, action, url, http, format, skip_view, slice, context)
+              generate_for_slice(controller, action, url, http, format, skip_view, skip_route, slice, context)
             else
-              generate_for_app(controller, action, url, http, format, skip_view, context)
+              generate_for_app(controller, action, url, http, format, skip_view, skip_route, context)
             end
           end
 
@@ -72,15 +72,17 @@ module Hanami
           attr_reader :inflector
 
           # rubocop:disable Metrics/AbcSize
-          def generate_for_slice(controller, action, url, http, format, skip_view, slice, context)
+          def generate_for_slice(controller, action, url, http, format, skip_view, skip_route, slice, context)
             slice_directory = fs.join("slices", slice)
             raise MissingSliceError.new(slice) unless fs.directory?(slice_directory)
 
-            fs.inject_line_at_block_bottom(
-              fs.join("config", "routes.rb"),
-              slice_matcher(slice),
-              route(controller, action, url, http)
-            )
+            if generate_route?(skip_route)
+              fs.inject_line_at_block_bottom(
+                fs.join("config", "routes.rb"),
+                slice_matcher(slice),
+                route(controller, action, url, http)
+              )
+            end
 
             fs.mkdir(directory = fs.join(slice_directory, "actions", controller))
             fs.write(fs.join(directory, "#{action}.rb"), t("slice_action.erb", context))
@@ -95,12 +97,14 @@ module Hanami
             end
           end
 
-          def generate_for_app(controller, action, url, http, format, skip_view, context)
-            fs.inject_line_at_class_bottom(
-              fs.join("config", "routes.rb"),
-              "class Routes",
-              route(controller, action, url, http)
-            )
+          def generate_for_app(controller, action, url, http, format, skip_view, skip_route, context)
+            if generate_route?(skip_route)
+              fs.inject_line_at_class_bottom(
+                fs.join("config", "routes.rb"),
+                "class Routes",
+                route(controller, action, url, http)
+              )
+            end
 
             fs.mkdir(directory = fs.join("app", "actions", controller))
             fs.write(fs.join(directory, "#{action}.rb"), t("action.erb", context))
@@ -137,6 +141,14 @@ module Hanami
             true
           end
 
+          # @api private
+          # @since 2.2.0
+          def generate_route?(skip_route)
+            return false if skip_route
+
+            true
+          end
+
           # @api private
           # @since 2.1.0
           def generate_restful_view?(view, directory)