hanami-cli 2.1.1 → 2.2.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc90cef87d08c779e3936a2431b93b647f43242c43cea6f85dc3fb22269c4647
-  data.tar.gz: 9eb4424fbdb88f535712951deaddc08874e76085b42fb8fd6d2715a3c3874af8
+  metadata.gz: eda4f18125d25c640cbb75e50a7e636b93e29badd50f6540b37c6fc55bb7cb98
+  data.tar.gz: 2d0f39b520d19a39866ccc354d40c1e9536f9b2c77d2ead33f340ddc64d899ef
 SHA512:
-  metadata.gz: b081dcb657e85809a9cd58e02ceeb4de28253e48e41ee030cae580c6ebb58a947255214a535bd9cf7f1061f7ee685749c8804da2e2ac2c8f203f81487ac88753
-  data.tar.gz: c524a51060f38143552ff8601511856348b88124f3597d55d4043a54791e356a45ac45ffbbd268b14f0a04f87caf7baa63d7d56750a6b7299c0f6e34d469216e
+  metadata.gz: 07052611a88815d7ffc2e228d77b62a65cc708283688c13e3509d3004a186b264d4271e104e8e3dea4dfae52958ccf9e385bc1a95c5c9b732e985538c82bfc7f
+  data.tar.gz: e6d3c5e3290fb2c19b6a301e11b20d70eb376a5c4da42ed69f7ceafa1590f5b14955b4cc9ce8bc0ad155e1db0ec3851aae06da43849d43441fe282cd94dd9860

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,21 @@ 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:
+      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
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 5432:5432

data/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 Hanami Command Line Interface
 
+## 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,15 @@ 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 "rack"
 
+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
 
@@ -44,4 +48,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,9 @@
+version: "2"
+services:
+  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

@@ -27,7 +27,7 @@ module Hanami
         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,116 @@
+# 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: fs,
+                fs: fs,
+                system_call: system_call,
+              ).call(...)
+            end
+
+            private
+
+            def databases(app: false, slice: nil)
+              if app
+                [database_for_app]
+              elsif slice
+                [database_for_slice(slice)]
+              else
+                all_databases
+              end
+            end
+
+            def database_for_app
+              build_database(app)
+            end
+
+            def database_for_slice(slice)
+              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)
+            end
+
+            def all_databases
+              slices = [app] + app.slices.with_nested
+
+              slices_by_database_url = slices.each_with_object({}) { |slice, hsh|
+                provider = slice.container.providers[:db]
+                next unless provider
+
+                database_url = provider.source.database_url
+                hsh[database_url] ||= []
+                hsh[database_url] << slice
+              }
+
+              databases = slices_by_database_url.each_with_object([]) { |(url, slices), arr|
+                slices_with_config = slices.select { _1.root.join("config", "db").directory? }
+
+                database = build_database(slices_with_config.first || slices.first)
+
+                warn_on_misconfigured_database database, slices_with_config
+
+                arr << database
+              }
+
+              databases
+            end
+
+            def build_database(slice)
+              Utils::Database[slice, system_call: system_call]
+            end
+
+            def warn_on_misconfigured_database(database, slices)
+              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 slices.length < 1
+                out.puts <<~STR
+                  WARNING: Database #{database.name} has no config/db/ directory.
+
+                STR
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,23 +1,31 @@
 # 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"
+
+            def call(app: false, slice: nil, command_exit: method(:exit), **)
+              exit_codes = []
+
+              databases(app: app, slice: slice).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,31 @@
 # 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"
+
+            def call(app: false, slice: nil, **)
+              exit_codes = []
+
+              databases(app: app, slice: slice).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,44 @@
 # 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 :target, desc: "Target migration number", aliases: ["-t"]
+            option :dump, required: false, type: :boolean, default: true,
+                          desc: "Dump the database structure after migrating"
 
-            # @api private
-            def call(target: nil, **)
-              return true if Dir[File.join(app.root, "db/migrate/*.rb")].empty?
+            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)
+              end
+
+              run_command(Structure::Dump, app: app, slice: slice, command_exit: command_exit) if dump
+            end
+
+            private
+
+            def migrate_database(database, target:)
+              return true unless migrations?(database)
 
               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 run_migrations(**options)
-              database.run_migrations(**options)
+            def migrations?(database)
+              database.migrations_dir? && database.sequel_migrator.files.any?
             end
           end
         end

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

@@ -0,0 +1,42 @@
+# 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, **)
+              exit_codes = []
+
+              databases(app: app, slice: slice).each do |database|
+                command_exit = -> code { throw :command_exited, code }
+                command_args = {slice: database.slice, command_exit: command_exit}
+
+                exit_code = catch :command_exited do
+                  unless database.exists?
+                    run_command(DB::Create, **command_args)
+                    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
+              end
+
+              exit_codes.each do |code|
+                break exit code if code > 0
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,39 +1,28 @@
 # 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 Seed < App::Command
-            FILE_PATH = "db/seeds.rb"
+          class Seed < DB::Command
+            SEEDS_PATH = "config/db/seeds.rb"
+            private_constant :SEEDS_PATH
 
             desc "Load seed data"
 
-            # @api private
-            def call(**)
-              if has_file?
-                measure "seed data loaded from #{FILE_PATH}" do
-                  load full_file_path
+            def call(app: false, slice: nil, **)
+              databases(app: app, slice: slice).each do |database|
+                seeds_path = database.slice.root.join(SEEDS_PATH)
+                next unless seeds_path.file?
+
+                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
-              else
-                out.puts "=> #{FILE_PATH} not found"
               end
             end
-
-            private
-
-            def full_file_path
-              File.join(app.root, FILE_PATH)
-            end
-
-            def has_file?
-              File.exist?(full_file_path)
-            end
           end
         end
       end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../../../app/command"
-
 module Hanami
   module CLI
     module Commands
@@ -10,13 +8,38 @@ module Hanami
           # @api private
           module Structure
             # @api private
-            class Dump < App::Command
-              desc "Dumps database structure to db/structure.sql file"
+            class Dump < DB::Command
+              desc "Dumps database structure to config/db/structure.sql file"
 
               # @api private
-              def call(*)
-                measure("#{database.name} structure dumped to db/structure.sql") do
-                  database.dump_command
+              def call(app: false, slice: 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)
+
+                  measure("#{database.name} structure dumped to #{relative_structure_path}") do
+                    catch :dump_failed do
+                      result = database.exec_dump_command
+                      exit_codes << result.exit_code if result.respond_to?(:exit_code)
+
+                      unless result.successful?
+                        out.puts result.err
+                        throw :dump_failed, false
+                      end
+
+                      File.open(structure_path, "a") do |f|
+                        f.puts "#{database.schema_migrations_sql_dump}\n"
+                      end
+
+                      true
+                    end
+                  end
+                end
+
+                exit_codes.each do |code|
+                  break command_exit.(code) if code > 0
                 end
               end
             end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        module DB
+          # @api private
+          module Structure
+            # @api private
+            class Load < DB::Command
+              STRUCTURE_PATH = File.join("config", "db", "structure.sql").freeze
+              private_constant :STRUCTURE_PATH
+
+              desc "Loads database from config/db/structure.sql file"
+
+              # @api private
+              def call(app: false, slice: 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?
+
+                  relative_structure_path = structure_path.relative_path_from(database.slice.app.root)
+
+                  measure("#{database.name} structure loaded from #{relative_structure_path}") do
+                    catch :load_failed do
+                      result = database.exec_load_command
+                      exit_codes << result.exit_code if result.respond_to?(:exit_code)
+
+                      unless result.successful?
+                        out.puts result.err
+                        throw :load_failed, false
+                      end
+
+                      true
+                    end
+                  end
+                end
+
+                exit_codes.each do |code|
+                  break command_exit.(code) if code > 0
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end