hanami-cli 2.2.0.beta1 → 2.2.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eda4f18125d25c640cbb75e50a7e636b93e29badd50f6540b37c6fc55bb7cb98
-  data.tar.gz: 2d0f39b520d19a39866ccc354d40c1e9536f9b2c77d2ead33f340ddc64d899ef
+  metadata.gz: e6ace925a2c5186088911d5df3d309d72ee0359e4691f70199c3f53f99db0fc3
+  data.tar.gz: 7fd1959ffcaf64ebc0b95a839a68ed1f052370ed6a7043863068087a1893489d
 SHA512:
-  metadata.gz: 07052611a88815d7ffc2e228d77b62a65cc708283688c13e3509d3004a186b264d4271e104e8e3dea4dfae52958ccf9e385bc1a95c5c9b732e985538c82bfc7f
-  data.tar.gz: e6d3c5e3290fb2c19b6a301e11b20d70eb376a5c4da42ed69f7ceafa1590f5b14955b4cc9ce8bc0ad155e1db0ec3851aae06da43849d43441fe282cd94dd9860
+  metadata.gz: 6133308e48b0623616598a23d1b0fe079b08f31e991791e6ae76867441eec1d25427deef5755e445fd8c3f2f2e294c143eeb58272e278721897ab290c48024cb
+  data.tar.gz: '068ad2b891fa99e16ff6c0be6931e98d708ce3c7bab67e0dd3fd354ef00f4bdb110ad84007592ccc98e65ebbe643f7e4420b0406f8b0b76500968a5571718398'

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,45 @@
 
 Hanami Command Line Interface
 
+## v2.2.0.rc1 - 2024-10-29
+
+### Added
+
+- [Tim Riley, François Beausoleil] Generate a `config/db/seeds.rb` file in new apps (#255, #256)
+
+### Changed
+
+- [Tim Riley] Add `--env` and `-e` options to all app commands, for setting the Hanami env (#246)
+- [Tim Riley] Keep test database in sync by applying `hanami db` commands to both development and test databases when invoked in development environment (#247)
+- [Kyle Plump] Add `--skip-route` flag to `generate action` and `generate slice` commands (#227)
+- [Tim Riley] Include a `change do` block in generated migrations (#254)
+- [Tim Riley] Generate MySQL database URL in `.env` that works with standard Homebrew MySQL installation (#249)
+- [Tim Riley, Adam Lassek] Remove ROM extension boilerplate in operations generated by `hanami new` and `generate operation` (this is now applied automatically) (#240, #252)
+- [François Beausoleil] Print a warning when running `db seed` but expected seeds files could not be found (#256)
+- [Seb Wilgosz] Only register `generate` subcommands if the relevant gems are bundled (#242)
+- [Anderson Saunders] When both IRB and pry are loaded, use IRB as the default engine for `hanami console` (#182)
+
+### Fixed
+
+- [Tim Riley] Fix error dumping structure when there are no migrations (#244)
+- [Tim Riley] Stop erroneous misconfigured DB warnings from `hanami db` commands when a database is configured once but shared across sliaces (#253)
+
+## 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 +49,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/command.rb

@@ -18,8 +18,8 @@ module Hanami
           # @api private
           ACTION_SEPARATOR = "." # TODO: rename to container key separator
 
-          # Overloads {Hanami::CLI::Commands::App::Command#call} to ensure an appropriate `HANAMI_ENV`
-          # environment variable is set.
+          # Overloads {Hanami::CLI::Commands::App::Command#call} to ensure an appropriate
+          # `HANAMI_ENV` environment variable is set.
           #
           # Uses an `--env` option if provided, then falls back to an already-set `HANAMI_ENV`
           # environment variable, and defaults to "development" in the absence of both.
@@ -27,6 +27,12 @@ module Hanami
           # @since 2.0.0
           # @api private
           module Environment
+            # @since 2.2.0
+            # @api private
+            def self.prepended(klass)
+              klass.option :env, desc: "App environment (development, test, production)", aliases: ["e"]
+            end
+
             # @since 2.0.0
             # @api private
             def call(*args, **opts)
@@ -37,7 +43,7 @@ module Hanami
               ENV["HANAMI_ENV"] = hanami_env
               Hanami::Env.load
 
-              super(*args, **opts)
+              super
             end
           end
 

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

@@ -51,11 +51,7 @@ module Hanami
           private
 
           def resolve_engine(engine, opts)
-            if engine
-              ENGINES.fetch(engine).(app, opts)
-            else
-              ENGINES.map { |(_, loader)| loader.(app, opts) }.compact.first
-            end
+            ENGINES.fetch(engine, ENGINES[DEFAULT_ENGINE]).call(app, opts)
           end
         end
       end

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

@@ -17,97 +17,205 @@ module Hanami
             option :app, required: false, type: :flag, default: false, desc: "Use app database"
             option :slice, required: false, desc: "Use database for slice"
 
+            # @api private
             attr_reader :system_call
 
+            # @api private
+            attr_reader :test_env_executor
+
             def initialize(
               out:, err:,
               system_call: SystemCall.new,
+              test_env_executor: InteractiveSystemCall.new(out: out, err: err),
+              nested_command: false,
               **opts
             )
               super(out: out, err: err, **opts)
               @system_call = system_call
+              @test_env_executor = test_env_executor
+              @nested_command = nested_command
             end
 
             def run_command(klass, ...)
               klass.new(
                 out: out,
-                inflector: fs,
+                inflector: inflector,
                 fs: fs,
                 system_call: system_call,
+                test_env_executor: test_env_executor,
+                nested_command: true,
               ).call(...)
             end
 
+            def nested_command?
+              @nested_command
+            end
+
             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
               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 {
+                  migrate_dir = _1[:gateway] == :default ? "migrate" : "#{_1[:gateway]}_migrate"
 
-                database = build_database(slices_with_config.first || slices.first)
+                  _1[:slice].root.join("config", "db", migrate_dir).directory?
+                }
 
-                warn_on_misconfigured_database database, slices_with_config
+                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, slice_gateways_with_config.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:
 
                   #{slices.map { "- " + _1.root.relative_path_from(_1.app.root).join("config", "db").to_s }.join("\n")}
 
-                  Migrating database using #{database.slice.slice_name.to_s.inspect} slice only.
+                  Using config in #{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
             end
+
+            # Invokes the currently executing `hanami` CLI command again, but with any `--env` args
+            # removed and the `HANAMI_ENV=test` env var set.
+            #
+            # This is called by certain `db` commands only, and runs only if the Hanami env is
+            # `:development`. This behavior important to streamline the local development
+            # experience, making sure that the test databases are kept in sync with operations run
+            # on the development databases.
+            #
+            # Spawning an entirely new process to change the env is a compromise approach until we
+            # can have an API for reinitializing the DB subsystem in-process with a different env.
+            def re_run_development_command_in_test
+              # Only invoke a new process if we've been called as `hanami`. This avoids awkward
+              # failures when testing commands via RSpec, for which the $0 is "/full/path/to/rspec".
+              return unless $0.end_with?("hanami")
+
+              # If this special env key is set, then a re-run has already been invoked. This would
+              # mean the current command is actually a nested command run by another db command. In
+              # this case, don't trigger a re-runs, because one is already in process.
+              return if nested_command?
+
+              # Re-runs in test are for development-env commands only.
+              return unless Hanami.env == :development
+
+              cmd = $0
+              cmd = "bundle exec #{cmd}" if ENV.key?("BUNDLE_BIN_PATH")
+
+              test_env_executor.call(
+                cmd, *argv_without_env_args,
+                env: {
+                  "HANAMI_ENV" => "test",
+                  "HANAMI_CLI_DB_COMMAND_RE_RUN_IN_TEST" => "true"
+                }
+              )
+            end
+
+            def re_running_in_test?
+              ENV.key?("HANAMI_CLI_DB_COMMAND_RE_RUN_IN_TEST")
+            end
+
+            # Returns the `ARGV` with every option argument included, but the `-e` or `--env` args
+            # removed.
+            def argv_without_env_args
+              new_argv = ARGV.dup
+
+              env_arg_index = new_argv.index {
+                _1 == "-e" || _1 == "--env" || _1.start_with?("-e=") || _1.start_with?("--env=")
+              }
+
+              if env_arg_index
+                # Remove the env argument
+                env_arg = new_argv.delete_at(env_arg_index)
+
+                # If the env argument is not in combined form ("--env foo" rather than "--env=foo"),
+                # then remove the following argument too
+                new_argv.delete_at(env_arg_index) if ["-e", "--env"].include?(env_arg)
+              end
+
+              new_argv
+            end
           end
         end
       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)
 
@@ -27,6 +29,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/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)
 
@@ -27,6 +29,8 @@ module Hanami
               exit_codes.each do |code|
                 break exit code if code > 0
               end
+
+              re_run_development_command_in_test
             end
           end
         end

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

@@ -9,22 +9,38 @@ 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
+
+              # Only dump for the initial command, not a re-run of the command in test env
+              if dump && !re_running_in_test?
+                run_command(
+                  Structure::Dump,
+                  app: app, slice: slice, gateway: gateway,
+                  command_exit: command_exit
+                )
               end
 
-              run_command(Structure::Dump, app: app, slice: slice, command_exit: command_exit) if dump
+              re_run_development_command_in_test
             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 +53,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,35 @@ 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) unless re_running_in_test?
+
+              re_run_development_command_in_test
             end
           end
         end

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

@@ -13,14 +13,30 @@ 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?
+
+                unless seeds_path.file?
+                  out.puts "no seeds found at #{seeds_path.relative_path_from(database.slice.app.root)}"
+                  next
+                end
 
                 relative_seeds_path = seeds_path.relative_path_from(database.slice.app.root)
                 measure "seed data loaded from #{relative_seeds_path}" do
                   load seeds_path.to_s
                 end
+
+                seeded_slices << database.slice
               end
             end
           end