hanami-cli 2.2.0.beta1 → 2.2.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eda4f18125d25c640cbb75e50a7e636b93e29badd50f6540b37c6fc55bb7cb98
-  data.tar.gz: 2d0f39b520d19a39866ccc354d40c1e9536f9b2c77d2ead33f340ddc64d899ef
+  metadata.gz: d62ed9aeff86f86693ffdf5acafb274e6e97a535a177bf46131c8c33141fc0e9
+  data.tar.gz: 86da7248a20712451a83b8e5167870e34fd508f2e5f41a107d9bf3a4dea1d376
 SHA512:
-  metadata.gz: 07052611a88815d7ffc2e228d77b62a65cc708283688c13e3509d3004a186b264d4271e104e8e3dea4dfae52958ccf9e385bc1a95c5c9b732e985538c82bfc7f
-  data.tar.gz: e6d3c5e3290fb2c19b6a301e11b20d70eb376a5c4da42ed69f7ceafa1590f5b14955b4cc9ce8bc0ad155e1db0ec3851aae06da43849d43441fe282cd94dd9860
+  metadata.gz: affe042dfe0daf2dc93e1252b06d2d51dd5ea605c1287ad2500371bed6ee98e902cf9d19667458f86edadabb671f923b986bcd2a76a0e7d8821f4e0b9af6ecf6
+  data.tar.gz: b1a097c66c10495ef31fd0783083d542ac6e7a5be7ab94f11b9e1a0d68dc865e04d6f970e08b88d33dd3939b47736cc8893989cb037d070d3c5d2ff86d35ccad

data/.github/workflows/ci.yml

@@ -41,6 +41,17 @@ jobs:
       - name: Run all tests
         run: bundle exec rake spec
     services:
+      mysql:
+        image: mysql:latest
+        env:
+          MYSQL_ROOT_PASSWORD: password
+        ports:
+          - 3307:3306
+        options: >-
+          --health-cmd "mysqladmin ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 3
       postgres:
         # Use postgres:14 for CLI compatibility with ubuntu-latest, currently ubuntu-22.04
         # See https://github.com/actions/runner-images/blob/main/images/ubuntu/Ubuntu2204-Readme.md
@@ -48,10 +59,10 @@ jobs:
         env:
           POSTGRES_USER: postgres
           POSTGRES_PASSWORD: password
+        ports:
+          - 5432:5432
         options: >-
           --health-cmd pg_isready
           --health-interval 10s
           --health-timeout 5s
           --health-retries 5
-        ports:
-          - 5432:5432

data/.rubocop.yml

@@ -42,3 +42,5 @@ Style/TrailingCommaInHashLiteral:
   Enabled: false
 Style/StringConcatenation:
   Enabled: false
+Style/ZeroLengthPredicate:
+  Enabled: false

data/CHANGELOG.md

@@ -2,9 +2,22 @@
 
 Hanami Command Line Interface
 
+## v2.2.0.beta2 - 2024-09-25
+
+### Added
+
+- [Tim Riley] MySQL support for `db` commands (#226)
+- [Tim Riley] Support for multiple gateways in `db` commands (#232, #234, #237, #238)
+
+### Changed
+
+- [Kyle Plump, Tim Riley] Delete `.keep` files when generating new files into previously empty directory (#224)
+- [Sean Collins] Add `db/*.sqlite` to the `.gitignore` in new apps (#210)
+- [Sean Collins] Print warnings for misconfigured databases when running `db` commands (#211)
+
 ## v2.2.0.beta1 - 2024-07-16
 
-## Added
+### Added
 
 - [Sean Collins] Generate db files in `hanami new` and `generate slice`
 - [Tim Riley] Add `db` commands: `create`, `drop`, `migrate`, `structure dump` `structure load`, `seed` `prepare`, `version`
@@ -13,7 +26,7 @@ Hanami Command Line Interface
 - [Krzysztof] Add `generate component` command
 - [Sean Collins] Add `generate operation` command
 
-## Changed
+### Changed
 
 - Drop support for Ruby 3.0
 

data/Gemfile

@@ -16,8 +16,11 @@ gem "hanami-db", github: "hanami/db", branch: "main"
 gem "hanami-router", github: "hanami/router", branch: "main"
 gem "hanami-utils", github: "hanami/utils", branch: "main"
 
+gem "dry-system", github: "dry-rb/dry-system", branch: "main"
+
 gem "rack"
 
+gem "mysql2"
 gem "pg"
 gem "sqlite3"
 

data/README.md

@@ -34,6 +34,8 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+In order to run all of the tests, you should run `docker compose up` separately, to run a `postgres` server.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/hanami/cli. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/hanami/cli/blob/main/CODE_OF_CONDUCT.md).

data/docker-compose.yml

@@ -1,5 +1,10 @@
-version: "2"
 services:
+  mysql:
+    image: mysql:latest
+    ports:
+      - 3307:3306
+    environment:
+      MYSQL_ROOT_PASSWORD: password
   postgres:
     image: postgres:latest
     ports:

data/lib/hanami/cli/command.rb

@@ -23,7 +23,7 @@ module Hanami
       def self.new(
         out: $stdout,
         err: $stderr,
-        fs: Hanami::CLI::Files.new,
+        fs: Hanami::CLI::Files.new(out: out),
         inflector: Dry::Inflector.new,
         **opts
       )

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

@@ -31,7 +31,7 @@ module Hanami
             def run_command(klass, ...)
               klass.new(
                 out: out,
-                inflector: fs,
+                inflector: inflector,
                 fs: fs,
                 system_call: system_call,
               ).call(...)
@@ -39,59 +39,87 @@ module Hanami
 
             private
 
-            def databases(app: false, slice: nil)
-              if app
-                [database_for_app]
-              elsif slice
-                [database_for_slice(slice)]
-              else
-                all_databases
+            def databases(app: false, slice: nil, gateway: nil)
+              if gateway && !app && !slice
+                err.puts "When specifying --gateway, an --app or --slice must also be given"
+                exit 1
               end
-            end
 
-            def database_for_app
-              build_database(app)
+              databases =
+                if slice
+                  [database_for_slice(slice, gateway: gateway)]
+                elsif app
+                  [database_for_slice(self.app, gateway: gateway)]
+                else
+                  all_databases
+                end
+
+              databases.flatten
             end
 
-            def database_for_slice(slice)
+            def database_for_slice(slice, gateway: nil)
               unless slice.is_a?(Class) && slice < Hanami::Slice
                 slice_name = inflector.underscore(Shellwords.shellescape(slice)).to_sym
                 slice = app.slices[slice_name]
               end
 
-              build_database(slice)
+              ensure_database_slice slice
+
+              databases = build_databases(slice)
+
+              if gateway
+                databases.fetch(gateway.to_sym) do
+                  err.puts %(No gateway "#{gateway}" in #{slice})
+                  exit 1
+                end
+              else
+                databases.values
+              end
             end
 
-            def all_databases
+            def all_databases # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
               slices = [app] + app.slices.with_nested
 
-              slices_by_database_url = slices.each_with_object({}) { |slice, hsh|
-                provider = slice.container.providers[:db]
-                next unless provider
+              slice_gateways_by_database_url = slices.each_with_object({}) { |slice, hsh|
+                db_provider_source = slice.container.providers[:db]&.source
+                next unless db_provider_source
 
-                database_url = provider.source.database_url
-                hsh[database_url] ||= []
-                hsh[database_url] << slice
+                db_provider_source.database_urls.each do |gateway, url|
+                  hsh[url] ||= []
+                  hsh[url] << {slice: slice, gateway: gateway}
+                end
               }
 
-              databases = slices_by_database_url.each_with_object([]) { |(url, slices), arr|
-                slices_with_config = slices.select { _1.root.join("config", "db").directory? }
+              slice_gateways_by_database_url.each_with_object([]) { |(url, slice_gateways), arr|
+                slice_gateways_with_config = slice_gateways.select {
+                  _1[:slice].root.join("config", "db").directory?
+                }
 
-                database = build_database(slices_with_config.first || slices.first)
+                db_slice_gateway = slice_gateways_with_config.first || slice_gateways.first
+                database = Utils::Database.database_class(url).new(
+                  slice: db_slice_gateway.fetch(:slice),
+                  gateway_name: db_slice_gateway.fetch(:gateway),
+                  system_call: system_call
+                )
 
-                warn_on_misconfigured_database database, slices_with_config
+                warn_on_misconfigured_database database, slice_gateways.map { _1.fetch(:slice) }
 
                 arr << database
               }
+            end
 
-              databases
+            def build_databases(slice)
+              Utils::Database.from_slice(slice: slice, system_call: system_call)
             end
 
-            def build_database(slice)
-              Utils::Database[slice, system_call: system_call]
+            def ensure_database_slice(slice)
+              return if slice.container.providers[:db]
+
+              out.puts "#{slice} does not have a :db provider."
+              exit 1
             end
 
-            def warn_on_misconfigured_database(database, slices)
+            def warn_on_misconfigured_database(database, slices) # rubocop:disable Metrics/AbcSize
               if slices.length > 1
                 out.puts <<~STR
                   WARNING: Database #{database.name} is configured for multiple config/db/ directories:
@@ -101,9 +129,13 @@ module Hanami
                   Migrating database using #{database.slice.slice_name.to_s.inspect} slice only.
 
                 STR
-              elsif slices.length < 1
+              elsif !database.db_config_dir?
+                relative_path = database.slice.root
+                  .relative_path_from(database.slice.app.root)
+                  .join("config", "db").to_s
+
                 out.puts <<~STR
-                  WARNING: Database #{database.name} has no config/db/ directory.
+                  WARNING: Database #{database.name} expects the folder #{relative_path}/ to exist but it does not.
 
                 STR
               end

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

@@ -9,10 +9,12 @@ module Hanami
           class Create < DB::Command
             desc "Create databases"
 
-            def call(app: false, slice: nil, command_exit: method(:exit), **)
+            option :gateway, required: false, desc: "Use database for gateway"
+
+            def call(app: false, slice: nil, gateway: nil, command_exit: method(:exit), **)
               exit_codes = []
 
-              databases(app: app, slice: slice).each do |database|
+              databases(app: app, slice: slice, gateway: gateway).each do |database|
                 result = database.exec_create_command
                 exit_codes << result.exit_code if result.respond_to?(:exit_code)
 

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

@@ -9,10 +9,12 @@ module Hanami
           class Drop < DB::Command
             desc "Delete databases"
 
-            def call(app: false, slice: nil, **)
+            option :gateway, required: false, desc: "Use database for gateway"
+
+            def call(app: false, slice: nil, gateway: nil, **)
               exit_codes = []
 
-              databases(app: app, slice: slice).each do |database|
+              databases(app: app, slice: slice, gateway: gateway).each do |database|
                 result = database.exec_drop_command
                 exit_codes << result.exit_code if result.respond_to?(:exit_code)
 

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

@@ -9,22 +9,29 @@ module Hanami
           class Migrate < DB::Command
             desc "Migrates database"
 
+            option :gateway, required: false, desc: "Use database for gateway"
             option :target, desc: "Target migration number", aliases: ["-t"]
             option :dump, required: false, type: :boolean, default: true,
-                          desc: "Dump the database structure after migrating"
+              desc: "Dump the database structure after migrating"
 
-            def call(target: nil, app: false, slice: nil, dump: true, command_exit: method(:exit), **)
-              databases(app: app, slice: slice).each do |database|
-                migrate_database(database, target: target)
+            def call(target: nil, app: false, slice: nil, gateway: nil, dump: true, command_exit: method(:exit), **)
+              databases(app: app, slice: slice, gateway: gateway).each do |database|
+                if migrations_dir_missing?(database)
+                  warn_on_missing_migrations_dir(database)
+                elsif no_migrations?(database)
+                  warn_on_empty_migrations_dir(database)
+                else
+                  migrate_database(database, target: target)
+                end
               end
 
-              run_command(Structure::Dump, app: app, slice: slice, command_exit: command_exit) if dump
+              run_command(Structure::Dump, app: app, slice: slice, gateway: gateway, command_exit: command_exit) if dump
             end
 
             private
 
             def migrate_database(database, target:)
-              return true unless migrations?(database)
+              return true unless database.migrations_dir?
 
               measure "database #{database.name} migrated" do
                 if target
@@ -37,8 +44,33 @@ module Hanami
               end
             end
 
-            def migrations?(database)
-              database.migrations_dir? && database.sequel_migrator.files.any?
+            def migrations_dir_missing?(database)
+              !database.migrations_dir?
+            end
+
+            def no_migrations?(database)
+              database.sequel_migrator.files.empty?
+            end
+
+            def warn_on_missing_migrations_dir(database)
+              out.puts <<~STR
+                WARNING: Database #{database.name} expects migrations to be located within #{relative_migrations_path(database)} but that folder does not exist.
+
+                No database migrations can be run for this database.
+              STR
+            end
+
+            def warn_on_empty_migrations_dir(database)
+              out.puts <<~STR
+                NOTE: Empty database migrations folder (#{relative_migrations_path(database)}) for #{database.name}
+              STR
+            end
+
+            def relative_migrations_path(database)
+              database
+                .migrations_path
+                .relative_path_from(database.slice.app.root)
+                .to_s + "/"
             end
           end
         end

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

@@ -10,11 +10,21 @@ module Hanami
             desc "Prepare databases"
 
             def call(app: false, slice: nil, **)
-              exit_codes = []
+              command_exit = -> code { throw :command_exited, code }
+              command_exit_arg = {command_exit: command_exit}
 
+              # Since any slice may have multiple databases, we need to run the steps below in a
+              # particular order to satisfy our ROM/Sequel's migrator, which requires _all_ the
+              # databases in a slice to be created before we can use it.
+              #
+              # So before we do anything else, make sure to create/load every database first.
               databases(app: app, slice: slice).each do |database|
-                command_exit = -> code { throw :command_exited, code }
-                command_args = {slice: database.slice, command_exit: command_exit}
+                command_args = {
+                  **command_exit_arg,
+                  app: database.slice.app?,
+                  slice: database.slice,
+                  gateway: database.gateway_name.to_s
+                }
 
                 exit_code = catch :command_exited do
                   unless database.exists?
@@ -22,17 +32,33 @@ module Hanami
                     run_command(DB::Structure::Load, **command_args)
                   end
 
-                  run_command(DB::Migrate, **command_args)
-                  run_command(DB::Seed, **command_args)
                   nil
                 end
 
-                exit_codes << exit_code if exit_code
+                return exit exit_code if exit_code.to_i > 1
               end
 
-              exit_codes.each do |code|
-                break exit code if code > 0
+              # Once all databases are created, the migrator will properly load for each slice, and
+              # we can migrate each database.
+              databases(app: app, slice: slice).each do |database|
+                command_args = {
+                  **command_exit_arg,
+                  app: database.slice.app?,
+                  slice: database.slice,
+                  gateway: database.gateway_name.to_s
+                }
+
+                exit_code = catch :command_exited do
+                  run_command(DB::Migrate, **command_args)
+
+                  nil
+                end
+
+                return exit exit_code if exit_code.to_i > 1
               end
+
+              # Finally, load the seeds for the slice overall, which is a once-per-slice operation.
+              run_command(DB::Seed, app: app, slice: slice)
             end
           end
         end

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

@@ -13,7 +13,17 @@ module Hanami
             desc "Load seed data"
 
             def call(app: false, slice: nil, **)
+              # We use `databases` below to discover the databases throughout the app and slices. It
+              # yields every database, so in a slice with multiple gateways, we'll see multiple
+              # databases for the slice.
+              #
+              # Since `db seed` is intended to run over whole slices only (not per-gateway), keep
+              # track of the seeded slices here, so we can avoid seeding a slice multiple times.
+              seeded_slices = []
+
               databases(app: app, slice: slice).each do |database|
+                next if seeded_slices.include?(database.slice)
+
                 seeds_path = database.slice.root.join(SEEDS_PATH)
                 next unless seeds_path.file?
 
@@ -21,6 +31,8 @@ module Hanami
                 measure "seed data loaded from #{relative_seeds_path}" do
                   load seeds_path.to_s
                 end
+
+                seeded_slices << database.slice
               end
             end
           end

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,7 +31,7 @@ module Hanami
                         throw :dump_failed, false
                       end
 
-                      File.open(structure_path, "a") do |f|
+                      File.open(database.structure_file, "a") do |f|
                         f.puts "#{database.schema_migrations_sql_dump}\n"
                       end
 

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

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,16 @@ module Hanami
                 )
               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
+
+              private
+
               def escaped_name
                 Shellwords.escape(name)
               end
@@ -66,14 +76,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/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/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/migration.rb

@@ -17,17 +17,14 @@ module Hanami
 
           # @since 2.2.0
           # @api private
-          def call(_app_namespace, name, slice, **_opts)
-            normalized_name = inflector.underscore(name)
-            ensure_valid_name(normalized_name)
+          def call(key:, base_path:, gateway: nil, **_opts)
+            name = inflector.underscore(key)
+            ensure_valid_name(name)
 
-            base = if slice
-                     fs.join("slices", slice, "config", "db", "migrate")
-                   else
-                     fs.join("config", "db", "migrate")
-                   end
+            base_path = nil if base_path == "app" # Migrations are in the root dir, not app/
+            migrate_dir = gateway ? "#{gateway}_migrate" : "migrate"
 
-            path = fs.join(base, file_name(normalized_name))
+            path = fs.join(*[base_path, "config", "db", migrate_dir, file_name(name)].compact)
 
             fs.write(path, FILE_CONTENTS)
           end

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

@@ -19,16 +19,17 @@ module Hanami
 
           # @since 2.2.0
           # @api private
-          def call(app_namespace, key, slice)
+          def call(key:, namespace:, base_path:)
             RubyFileWriter.new(
               fs: fs,
               inflector: inflector,
-              app_namespace: app_namespace,
+            ).call(
+              namespace: namespace,
+              base_path: base_path,
               key: key,
-              slice: slice,
               relative_parent_class: "Operation",
               body: ["def call", "end"],
-            ).call
+            )
 
             unless key.match?(KEY_SEPARATOR)
               out.puts(

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

@@ -19,19 +19,20 @@ module Hanami
 
           # @since 2.2.0
           # @api private
-          def call(app_namespace, key, slice)
+          def call(key:, namespace:, base_path:)
             schema_name = key.split(KEY_SEPARATOR).last
 
             RubyFileWriter.new(
               fs: fs,
               inflector: inflector,
-              app_namespace: app_namespace,
+            ).call(
+              namespace: namespace,
               key: key,
-              slice: slice,
+              base_path: base_path,
               extra_namespace: "Relations",
               relative_parent_class: "DB::Relation",
               body: ["schema :#{schema_name}, infer: true"],
-            ).call
+            )
           end
 
           private

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

@@ -17,17 +17,18 @@ module Hanami
 
           # @since 2.2.0
           # @api private
-          def call(app_namespace, key, slice)
+          def call(key:, namespace:, base_path:)
             RubyFileWriter.new(
               fs: fs,
               inflector: inflector,
-              app_namespace: app_namespace,
+            ).call(
               key: key,
-              slice: slice,
+              namespace: namespace,
+              base_path: base_path,
               extra_namespace: "Repos",
               relative_parent_class: "DB::Repo",
               body: [],
-            ).call
+            )
           end
 
           private

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

@@ -14,31 +14,55 @@ module Hanami
         class RubyFileWriter
           # @since 2.2.0
           # @api private
+          def initialize(fs:, inflector:)
+            @fs = fs
+            @inflector = inflector
+          end
+
+          # @since 2.2.0
+          # @api private
+          def call(key:, namespace:, base_path:, relative_parent_class:, extra_namespace: nil, body: [])
+            ClassFile.new(
+              fs: fs,
+              inflector: inflector,
+              key: key,
+              namespace: namespace,
+              base_path: base_path,
+              relative_parent_class: relative_parent_class,
+              extra_namespace: extra_namespace,
+              body: body,
+            ).write
+          end
+
+          private
+
+          # @since 2.2.0
+          # @api private
+          attr_reader :fs, :inflector
+        end
+
+        class ClassFile
           def initialize(
             fs:,
             inflector:,
-            app_namespace:,
             key:,
-            slice:,
+            namespace:,
+            base_path:,
             relative_parent_class:,
             extra_namespace: nil,
             body: []
           )
             @fs = fs
             @inflector = inflector
-            @app_namespace = app_namespace
             @key = key
-            @slice = slice
+            @namespace = namespace
+            @base_path = base_path
             @extra_namespace = extra_namespace&.downcase
             @relative_parent_class = relative_parent_class
             @body = body
-            raise_missing_slice_error_if_missing(slice) if slice
           end
 
-          # @since 2.2.0
-          # @api private
-          def call
-            fs.mkdir(directory)
+          def write
             fs.write(path, file_contents)
           end
 
@@ -49,9 +73,9 @@ module Hanami
           attr_reader(
             :fs,
             :inflector,
-            :app_namespace,
             :key,
-            :slice,
+            :namespace,
+            :base_path,
             :extra_namespace,
             :relative_parent_class,
             :body,
@@ -62,7 +86,6 @@ module Hanami
           def file_contents
             class_definition(
               class_name: class_name,
-              container_namespace: container_namespace,
               local_namespaces: local_namespaces,
             )
           end
@@ -73,12 +96,6 @@ module Hanami
             key.split(KEY_SEPARATOR)[-1]
           end
 
-          # @since 2.2.0
-          # @api private
-          def container_namespace
-            slice || app_namespace
-          end
-
           # @since 2.2.0
           # @api private
           def local_namespaces
@@ -88,16 +105,10 @@ module Hanami
           # @since 2.2.0
           # @api private
           def directory
-            base = if slice
-                     fs.join("slices", slice)
-                   else
-                     fs.join("app")
-                   end
-
             @directory ||= if local_namespaces.any?
-                             fs.join(base, local_namespaces)
+                             fs.join(base_path, local_namespaces)
                            else
-                             fs.join(base)
+                             base_path
                            end
           end
 
@@ -109,8 +120,8 @@ module Hanami
 
           # @since 2.2.0
           # @api private
-          def class_definition(class_name:, container_namespace:, local_namespaces:)
-            container_module = normalize(container_namespace)
+          def class_definition(class_name:, local_namespaces:)
+            container_module = normalize(namespace)
 
             modules = local_namespaces
               .map { normalize(_1) }
@@ -133,15 +144,6 @@ module Hanami
           def normalize(name)
             inflector.camelize(name).gsub(/[^\p{Alnum}]/, "")
           end
-
-          # @since 2.2.0
-          # @api private
-          def raise_missing_slice_error_if_missing(slice)
-            if slice
-              slice_directory = fs.join("slices", slice)
-              raise MissingSliceError.new(slice) unless fs.directory?(slice_directory)
-            end
-          end
         end
       end
     end

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

@@ -17,16 +17,17 @@ module Hanami
 
           # @since 2.2.0
           # @api private
-          def call(app_namespace, key, slice)
+          def call(key:, namespace:, base_path:)
             RubyFileWriter.new(
               fs: fs,
               inflector: inflector,
-              app_namespace: app_namespace,
+            ).call(
               key: key,
-              slice: slice,
+              namespace: namespace,
+              base_path: base_path,
               extra_namespace: "Structs",
               relative_parent_class: "DB::Struct",
-            ).call
+            )
           end
 
           private

data/lib/hanami/cli/generators/context.rb

@@ -89,19 +89,19 @@ module Hanami
         # @since 2.2.0
         # @api private
         def generate_sqlite?
-          database_option == Commands::Gem::New::DATABASE_SQLITE
+          generate_db? && database_option == Commands::Gem::New::DATABASE_SQLITE
         end
 
         # @since 2.2.0
         # @api private
         def generate_postgres?
-          database_option == Commands::Gem::New::DATABASE_POSTGRES
+          generate_db? && database_option == Commands::Gem::New::DATABASE_POSTGRES
         end
 
         # @since 2.2.0
         # @api private
         def generate_mysql?
-          database_option == Commands::Gem::New::DATABASE_MYSQL
+          generate_db? && database_option == Commands::Gem::New::DATABASE_MYSQL
         end
 
         # @since 2.2.0
@@ -112,7 +112,7 @@ module Hanami
           elsif generate_postgres?
             "postgres://localhost/#{app}"
           elsif generate_mysql?
-            "mysql://localhost/#{app}"
+            "mysql2://localhost/#{app}"
           else
             raise "Unknown database option: #{database_option}"
           end

data/lib/hanami/cli/generators/gem/app/gitignore.erb

@@ -4,3 +4,6 @@ log/*
 public/
 node_modules/
 <%- end -%>
+<%- if generate_sqlite? -%>
+db/*.sqlite
+<%- end -%>

data/lib/hanami/cli/version.rb

@@ -6,6 +6,6 @@ module Hanami
     #
     # @api public
     # @since 2.0.0
-    VERSION = "2.2.0.beta1"
+    VERSION = "2.2.0.beta2"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hanami-cli
 version: !ruby/object:Gem::Version
-  version: 2.2.0.beta1
+  version: 2.2.0.beta2
 platform: ruby
 authors:
 - Luca Guidi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-16 00:00:00.000000000 Z
+date: 2024-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -263,7 +263,6 @@ files:
 - lib/hanami/cli/generators/app/slice/app_css.erb
 - lib/hanami/cli/generators/app/slice/app_js.erb
 - lib/hanami/cli/generators/app/slice/app_layout.erb
-- lib/hanami/cli/generators/app/slice/entities.erb
 - lib/hanami/cli/generators/app/slice/favicon.ico
 - lib/hanami/cli/generators/app/slice/helpers.erb
 - lib/hanami/cli/generators/app/slice/keep.erb
@@ -354,7 +353,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
 summary: Hanami CLI

data/lib/hanami/cli/generators/app/slice/entities.erb

@@ -1,9 +0,0 @@
-# auto_register: false
-# frozen_string_literal: true
-
-module <%= camelized_slice_name %>
-  module Entities
-  end
-end
-
-Dir[File.join(__dir__, "entities", "*.rb")].each(&method(:require))