hanami-cli 2.1.1 → 2.2.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc90cef87d08c779e3936a2431b93b647f43242c43cea6f85dc3fb22269c4647
-  data.tar.gz: 9eb4424fbdb88f535712951deaddc08874e76085b42fb8fd6d2715a3c3874af8
+  metadata.gz: d62ed9aeff86f86693ffdf5acafb274e6e97a535a177bf46131c8c33141fc0e9
+  data.tar.gz: 86da7248a20712451a83b8e5167870e34fd508f2e5f41a107d9bf3a4dea1d376
 SHA512:
-  metadata.gz: b081dcb657e85809a9cd58e02ceeb4de28253e48e41ee030cae580c6ebb58a947255214a535bd9cf7f1061f7ee685749c8804da2e2ac2c8f203f81487ac88753
-  data.tar.gz: c524a51060f38143552ff8601511856348b88124f3597d55d4043a54791e356a45ac45ffbbd268b14f0a04f87caf7baa63d7d56750a6b7299c0f6e34d469216e
+  metadata.gz: affe042dfe0daf2dc93e1252b06d2d51dd5ea605c1287ad2500371bed6ee98e902cf9d19667458f86edadabb671f923b986bcd2a76a0e7d8821f4e0b9af6ecf6
+  data.tar.gz: b1a097c66c10495ef31fd0783083d542ac6e7a5be7ab94f11b9e1a0d68dc865e04d6f970e08b88d33dd3939b47736cc8893989cb037d070d3c5d2ff86d35ccad

data/.github/workflows/ci.yml

@@ -27,15 +27,9 @@ jobs:
           - "3.3"
           - "3.2"
           - "3.1"
-          - "3.0"
+    env:
+      POSTGRES_BASE_URL: postgres://postgres:password@localhost:5432/hanami_cli_test
     steps:
-      - uses: ravsamhq/notify-slack-action@v1
-        if: always()
-        with:
-          status: ${{ job.status }}
-          notify_when: "failure"
-        env:
-          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
       - uses: actions/checkout@v1
       - name: Install package dependencies
         run: "[ -e $APT_DEPS ] || sudo apt-get install -y --no-install-recommends $APT_DEPS"
@@ -43,10 +37,32 @@ jobs:
         uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{matrix.ruby}}
-      - name: Install latest bundler
-        run: |
-          gem install bundler --no-document
-      - name: Bundle install
-        run: bundle install --jobs 4 --retry 3
+          bundler-cache: true
       - 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
+        image: postgres:14
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: password
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5

data/.rubocop.yml

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

data/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 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
+
+- [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`
+- [Tim Riley] Support SQLite and Postgres for `db` commands
+- [Sean Collins] Add `generate` commands for db components: `generate migration`, `generate relation`, `generate repo`, `generate struct`
+- [Krzysztof] Add `generate component` command
+- [Sean Collins] Add `generate operation` command
+
+### Changed
+
+- Drop support for Ruby 3.0
+
 ## v2.1.1 - 2024-03-19
 
 ### Fixed

data/Gemfile

@@ -12,13 +12,18 @@ end
 gem "hanami", github: "hanami/hanami", branch: "main"
 gem "hanami-assets", github: "hanami/assets", branch: "main"
 gem "hanami-controller", github: "hanami/controller", branch: "main"
+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-files", github: "dry-rb/dry-files", branch: "main"
+gem "dry-system", github: "dry-rb/dry-system", branch: "main"
 
 gem "rack"
 
+gem "mysql2"
+gem "pg"
+gem "sqlite3"
+
 gem "hanami-devtools", github: "hanami/devtools", branch: "main"
 
 group :test do

data/README.md

@@ -1,13 +1,15 @@
 # Hanami::CLI
 
-CLI commands for [full-stack Hanami applications](`https://github.com/hanami/hanami`).
+This library contains all of the CLI commands for [full-stack Hanami applications](`https://github.com/hanami/hanami`).
 
-**NOTE**: For versions 0.4 and below, there was a general purpose CLI utility library with this same name. That library has since been renamed to [dry-rb/dry-cli](https://github.com/dry-rb/dry-cli). Please update your Gemfiles accordingly.
+**NOTE**: For versions 0.4 and below, there was a general purpose CLI utility library with this name.
+That library has since been renamed to [dry-rb/dry-cli](https://github.com/dry-rb/dry-cli).
+Please update your Gemfiles accordingly.
 
 ## Status
 
 [![Gem Version](https://badge.fury.io/rb/hanami-cli.svg)](https://badge.fury.io/rb/hanami-cli)
-[![CI](https://github.com/hanami/cli/workflows/ci/badge.svg?branch=main)](https://github.com/hanami/cli/actions?query=workflow%3Aci+branch%3Amain)
+[![CI](https://github.com/hanami/cli/actions/workflows/ci.yml/badge.svg)](https://github.com/hanami/cli/actions?query=workflow%3Aci+branch%3Amain)
 [![Depfu](https://badges.depfu.com/badges/a8545fb67cf32a2c75b6227bc0821027/overview.svg)](https://depfu.com/github/hanami/cli?project=Bundler)
 
 ## Contact
@@ -15,12 +17,14 @@ CLI commands for [full-stack Hanami applications](`https://github.com/hanami/han
 - Home page: http://hanamirb.org
 - Mailing List: http://hanamirb.org/mailing-list
 - Bugs/Issues: https://github.com/hanami/cli/issues
-- Support: http://stackoverflow.com/questions/tagged/hanami
+- API Doc: http://rubydoc.info/gems/hanami-cli
 - Chat: http://chat.hanamirb.org
 
-## Rubies
+## Installation
 
-**Hanami::RSpec** supports Ruby (MRI) 3.0+
+**Hanami::CLI** supports Ruby (MRI) 3.1+
+
+This library is a dependency of the main `hanami` gem, so installing that is the best way to get and use this gem.
 
 ## Usage
 
@@ -30,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).
@@ -44,4 +50,4 @@ Everyone interacting in the `Hanami::CLI` project's codebases, issue trackers, c
 
 ## Copyright
 
-Copyright © 2014 Hanami Team – Released under MIT License
+Copyright © 2014–2024 Hanami Team – Released under MIT License

data/docker-compose.yml

@@ -0,0 +1,14 @@
+services:
+  mysql:
+    image: mysql:latest
+    ports:
+      - 3307:3306
+    environment:
+      MYSQL_ROOT_PASSWORD: password
+  postgres:
+    image: postgres:latest
+    ports:
+      - 5433:5432
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: password

data/hanami-cli.gemspec

@@ -28,10 +28,10 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
   spec.metadata["rubygems_mfa_required"] = "true"
-  spec.required_ruby_version = ">= 3.0"
+  spec.required_ruby_version = ">= 3.1"
 
   spec.add_dependency "bundler", "~> 2.1"
-  spec.add_dependency "dry-cli", "~> 1.0", "< 2"
+  spec.add_dependency "dry-cli", "~> 1.0", ">= 1.1.0"
   spec.add_dependency "dry-files", "~> 1.0", ">= 1.0.2", "< 2"
   spec.add_dependency "dry-inflector", "~> 1.0", "< 2"
   spec.add_dependency "rake", "~> 13.0"

data/lib/hanami/cli/command.rb

@@ -23,11 +23,11 @@ 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
       )
-        super(out: out, err: err, fs: fs, inflector: inflector, **opts)
+        super
       end
 
       # Returns a new command.

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

@@ -71,12 +71,12 @@ module Hanami
           #
           # @since 2.0.0
           # @api public
-          def run_command(klass, *args)
+          def run_command(klass, ...)
             klass.new(
               out: out,
               inflector: app.inflector,
               fs: Hanami::CLI::Files,
-            ).call(*args)
+            ).call(...)
           end
 
           # Executes a given block and prints string to the `out` stream with details of the time
@@ -111,20 +111,6 @@ module Hanami
               out.puts "!!! => #{desc.inspect} FAILED"
             end
           end
-
-          # This is NOT AVAILABLE as of the 2.0.0 release.
-          #
-          # @api private
-          def database
-            @database ||= Commands::App::DB::Utils::Database[app]
-          end
-
-          # This is NOT AVAILABLE as of the 2.0.0 release.
-          #
-          # @api private
-          def database_config
-            database.config
-          end
         end
       end
     end

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require_relative "utils/database"
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        module DB
+          # Base class for `hanami` CLI commands intended to be executed within an existing Hanami
+          # app.
+          #
+          # @since 2.2.0
+          # @api private
+          class Command < App::Command
+            option :app, required: false, type: :flag, default: false, desc: "Use app database"
+            option :slice, required: false, desc: "Use database for slice"
+
+            attr_reader :system_call
+
+            def initialize(
+              out:, err:,
+              system_call: SystemCall.new,
+              **opts
+            )
+              super(out: out, err: err, **opts)
+              @system_call = system_call
+            end
+
+            def run_command(klass, ...)
+              klass.new(
+                out: out,
+                inflector: inflector,
+                fs: fs,
+                system_call: system_call,
+              ).call(...)
+            end
+
+            private
+
+            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
+
+              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, 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
+
+              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 # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
+              slices = [app] + app.slices.with_nested
+
+              slice_gateways_by_database_url = slices.each_with_object({}) { |slice, hsh|
+                db_provider_source = slice.container.providers[:db]&.source
+                next unless db_provider_source
+
+                db_provider_source.database_urls.each do |gateway, url|
+                  hsh[url] ||= []
+                  hsh[url] << {slice: slice, gateway: gateway}
+                end
+              }
+
+              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?
+                }
+
+                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.map { _1.fetch(:slice) }
+
+                arr << database
+              }
+            end
+
+            def build_databases(slice)
+              Utils::Database.from_slice(slice: slice, system_call: system_call)
+            end
+
+            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) # 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.
+
+                STR
+              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} expects the folder #{relative_path}/ to exist but it does not.
+
+                STR
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,23 +1,33 @@
 # frozen_string_literal: true
 
-require_relative "../../app/command"
-
 module Hanami
   module CLI
     module Commands
       module App
         module DB
           # @api private
-          class Create < App::Command
-            desc "Create database"
+          class Create < DB::Command
+            desc "Create databases"
+
+            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, gateway: gateway).each do |database|
+                result = database.exec_create_command
+                exit_codes << result.exit_code if result.respond_to?(:exit_code)
+
+                if result == true || result.successful?
+                  out.puts "=> database #{database.name} created"
+                else
+                  out.puts "=> failed to create database #{database.name}"
+                  out.puts "#{result.err}\n"
+                end
+              end
 
-            # @api private
-            def call(**)
-              if database.create_command
-                out.puts "=> database #{database.name} created"
-              else
-                out.puts "=> failed to create database #{database.name}"
-                exit $?.exitstatus
+              exit_codes.each do |code|
+                break command_exit.(code) if code > 0
               end
             end
           end

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

@@ -1,22 +1,33 @@
 # frozen_string_literal: true
 
-require_relative "../../app/command"
-
 module Hanami
   module CLI
     module Commands
       module App
         module DB
           # @api private
-          class Drop < App::Command
-            desc "Delete database"
+          class Drop < DB::Command
+            desc "Delete databases"
+
+            option :gateway, required: false, desc: "Use database for gateway"
+
+            def call(app: false, slice: nil, gateway: nil, **)
+              exit_codes = []
+
+              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)
+
+                if result == true || result.successful?
+                  out.puts "=> database #{database.name} dropped"
+                else
+                  out.puts "=> failed to drop database #{database.name}"
+                  out.puts "#{result.err}\n"
+                end
+              end
 
-            # @api private
-            def call(**)
-              if database.drop_command
-                out.puts "=> database #{database.name} dropped"
-              else
-                out.puts "=> failed to drop #{database.name}"
+              exit_codes.each do |code|
+                break exit code if code > 0
               end
             end
           end

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

@@ -1,38 +1,76 @@
 # frozen_string_literal: true
 
-require_relative "../../app/command"
-require_relative "structure/dump"
-
 module Hanami
   module CLI
     module Commands
       module App
         module DB
           # @api private
-          class Migrate < App::Command
+          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"
+
+            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, gateway: gateway, command_exit: command_exit) if dump
+            end
+
+            private
 
-            # @api private
-            def call(target: nil, **)
-              return true if Dir[File.join(app.root, "db/migrate/*.rb")].empty?
+            def migrate_database(database, target:)
+              return true unless database.migrations_dir?
 
               measure "database #{database.name} migrated" do
                 if target
-                  run_migrations(target: Integer(target))
+                  database.run_migrations(target: Integer(target))
                 else
-                  run_migrations
+                  database.run_migrations
                 end
 
                 true
               end
             end
 
-            private
+            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 run_migrations(**options)
-              database.run_migrations(**options)
+            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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        module DB
+          # @api private
+          class Prepare < DB::Command
+            desc "Prepare databases"
+
+            def call(app: false, slice: nil, **)
+              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_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?
+                    run_command(DB::Create, **command_args)
+                    run_command(DB::Structure::Load, **command_args)
+                  end
+
+                  nil
+                end
+
+                return exit exit_code if exit_code.to_i > 1
+              end
+
+              # 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
+      end
+    end
+  end
+end