hanami-cli 2.1.0 → 2.2.0.beta1

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

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "database_config"
+require "uri"
 
 module Hanami
   module CLI
@@ -9,15 +9,14 @@ module Hanami
         module DB
           module Utils
             # @api private
+            # @since 2.2.0
             class Database
-              # @api private
-              attr_reader :app
+              MIGRATIONS_DIR = "config/db/migrate"
+              private_constant :MIGRATIONS_DIR
 
-              # @api private
-              attr_reader :config
-
-              # @api private
-              SCHEME_MAP = {
+              DATABASE_CLASS_RESOLVER = Hash.new { |_, key|
+                raise "#{key} is not a supported db scheme"
+              }.update(
                 "sqlite" => -> {
                   require_relative("sqlite")
                   Sqlite
@@ -34,84 +33,66 @@ module Hanami
                   require_relative("mysql")
                   Mysql
                 }
-              }.freeze
-
-              # @api private
-              def self.[](app)
-                database_url =
-                  if app.key?(:settings) && app[:settings].respond_to?(:database_url)
-                    app[:settings].database_url
-                  else
-                    ENV.fetch("DATABASE_URL")
-                  end
+              ).freeze
 
-                config = DatabaseConfig.new(database_url)
+              def self.[](slice, system_call:)
+                provider = slice.container.providers[:db]
+                raise "this is not a db slice" unless provider
 
-                resolver = SCHEME_MAP.fetch(config.db_type) do
-                  raise "#{config.db_type} is not a supported db scheme"
-                end
+                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)
+              end
+
+              attr_reader :slice
 
-                klass = resolver.()
+              attr_reader :system_call
 
-                klass.new(app: app, config: config)
+              def initialize(slice:, system_call:)
+                @slice = slice
+                @system_call = system_call
               end
 
-              # @api private
-              def initialize(app:, config:)
-                @app = app
-                @config = config
+              def name
+                database_uri.path.sub(%r{^/}, "")
               end
 
-              # @api private
-              def create_command
-                raise Hanami::CLI::NotImplementedError
+              def database_url
+                slice.container.providers[:db].source.database_url
               end
 
-              # @api private
-              def drop_command
-                raise Hanami::CLI::NotImplementedError
+              def database_uri
+                @database_uri ||= URI(database_url)
               end
 
-              # @api private
-              def dump_command
-                raise Hanami::CLI::NotImplementedError
+              def gateway
+                slice["db.config"].gateways[:default]
               end
 
-              # @api private
-              def load_command
-                raise Hanami::CLI::NotImplementedError
+              def connection
+                gateway.connection
               end
 
-              # @api private
-              def root_path
-                app.root
+              def exec_create_command
+                raise Hanami::CLI::NotImplementedError
               end
 
-              # @api private
-              def rom_config
-                @rom_config ||=
-                  begin
-                    app.prepare(:persistence)
-                    app.container["persistence.config"]
-                  end
+              def exec_drop_command
+                raise Hanami::CLI::NotImplementedError
               end
 
-              # @api private
-              def name
-                config.db_name
+              def exists?
+                raise Hanami::CLI::NotImplementedError
               end
 
-              # @api private
-              def gateway
-                rom_config.gateways[:default]
+              def exec_dump_command
+                raise Hanami::CLI::NotImplementedError
               end
 
-              # @api private
-              def connection
-                gateway.connection
+              def exec_load_command
+                raise Hanami::CLI::NotImplementedError
               end
 
-              # @api private
               def run_migrations(**options)
                 require "rom/sql"
                 ROM::SQL.with_gateway(gateway) do
@@ -119,24 +100,19 @@ module Hanami
                 end
               end
 
-              # @api private
               def migrator
-                @migrator ||=
-                  begin
-                    require "rom/sql"
-                    ROM::SQL::Migration::Migrator.new(connection, path: File.join(root_path, "db/migrate"))
-                  end
-              end
+                @migrator ||= begin
+                  slice.prepare :db
 
-              # @api private
-              def applied_migrations
-                sequel_migrator.applied_migrations
+                  require "rom/sql"
+                  ROM::SQL::Migration::Migrator.new(connection, path: migrations_path)
+                end
               end
 
-              private
-
               def sequel_migrator
                 @sequel_migrator ||= begin
+                  slice.prepare :db
+
                   require "sequel"
                   Sequel.extension :migration
 
@@ -147,8 +123,27 @@ module Hanami
                 end
               end
 
+              def applied_migrations
+                sequel_migrator.applied_migrations
+              end
+
               def migrations_path
-                File.join(root_path, "db/migrate")
+                slice.root.join(MIGRATIONS_DIR)
+              end
+
+              def migrations_dir?
+                migrations_path.directory?
+              end
+
+              def structure_file
+                slice.root.join("config/db/structure.sql")
+              end
+
+              def schema_migrations_sql_dump
+                sql = +"INSERT INTO schema_migrations (filename) VALUES\n"
+                sql << applied_migrations.map { |v| "('#{v}')" }.join(",\n")
+                sql << ";"
+                sql
               end
             end
           end

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

@@ -16,12 +16,12 @@ module Hanami
               end
 
               # @api private
-              def dump_command
+              def exec_dump_command
                 raise Hanami::CLI::NotImplementedError
               end
 
               # @api private
-              def load_command
+              def exec_load_command
                 raise Hanami::CLI::NotImplementedError
               end
             end

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

@@ -11,49 +11,68 @@ module Hanami
         module DB
           module Utils
             # @api private
+            # @since 2.2.0
             class Postgres < Database
               # @api private
-              def create_command
-                existing_stdout, status = Open3.capture2(cli_env_vars, "psql -t -c '\\l #{escaped_name}'")
+              # @since 2.2.0
+              def exec_create_command
+                return true if exists?
 
-                return true if status.success? && existing_stdout.include?(escaped_name)
-
-                system(cli_env_vars, "createdb #{escaped_name}")
+                system_call.call("createdb #{escaped_name}", env: cli_env_vars)
               end
 
               # @api private
-              def drop_command
-                system(cli_env_vars, "dropdb #{escaped_name}")
+              # @since 2.2.0
+              def exec_drop_command
+                return true unless exists?
+
+                system_call.call("dropdb #{escaped_name}", env: cli_env_vars)
               end
 
               # @api private
-              def dump_command
-                system(cli_env_vars, "pg_dump --schema-only --no-owner #{escaped_name} > #{dump_file}")
+              # @since 2.2.0
+              def exists?
+                result = system_call.call("psql -t -A -c '\\list #{escaped_name}'", env: cli_env_vars)
+                result.successful? && result.out.include?("#{name}|") # start_with?
               end
 
               # @api private
-              def load_command
-                raise "Not Implemented Yet"
+              # @since 2.2.0
+              def exec_dump_command
+                system_call.call(
+                  "pg_dump --schema-only --no-privileges --no-owner --file #{structure_file} #{escaped_name}",
+                  env: cli_env_vars
+                )
               end
 
               # @api private
+              # @since 2.2.0
+              def exec_load_command
+                system_call.call(
+                  "psql --set ON_ERROR_STOP=1 --quiet --no-psqlrc --output #{File::NULL} --file #{structure_file} #{escaped_name}",
+                  env: cli_env_vars
+                )
+              end
+
               def escaped_name
                 Shellwords.escape(name)
               end
 
-              # @api private
               def cli_env_vars
                 @cli_env_vars ||= {}.tap do |vars|
-                  vars["PGHOST"] = config.host.to_s
-                  vars["PGPORT"] = config.port.to_s if config.port
-                  vars["PGUSER"] = config.user.to_s if config.user
-                  vars["PGPASSWORD"] = config.pass.to_s if config.pass
+                  vars["PGHOST"] = database_uri.host.to_s if database_uri.host
+                  vars["PGPORT"] = database_uri.port.to_s if database_uri.port
+                  vars["PGUSER"] = database_uri.user.to_s if database_uri.user
+                  vars["PGPASSWORD"] = database_uri.password.to_s if database_uri.password
                 end
               end
 
-              # @api private
-              def dump_file
-                "#{root_path}/db/structure.sql"
+              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

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

@@ -9,32 +9,80 @@ module Hanami
         module DB
           module Utils
             # @api private
+            # @since 2.2.0
             class Sqlite < Database
               # @api private
-              def create_command
-                rom_config
-                true
+              # @since 2.2.0
+              Failure = Struct.new(:err) do
+                def successful?
+                  false
+                end
+
+                def exit_code
+                  1
+                end
+              end
+
+              # @api private
+              # @since 2.2.0
+              def exec_create_command
+                return true if exists?
+
+                FileUtils.mkdir_p(File.dirname(file_path))
+
+                system_call.call(%(sqlite3 #{file_path} "VACUUM;"))
               end
 
               # @api private
-              def drop_command
-                file_path.unlink
+              # @since 2.2.0
+              def exec_drop_command
+                begin
+                  File.unlink(file_path) if exists?
+                rescue => e
+                  # Mimic a system_call result
+                  return Failure.new(e.message)
+                end
+
                 true
               end
 
               # @api private
-              def dump_command
-                raise Hanami::CLI::NotImplementedError
+              # @since 2.2.0
+              def exists?
+                File.exist?(file_path)
+              end
+
+              # @api private
+              # @since 2.2.0
+              def exec_dump_command
+                system_call.call(%(sqlite3 #{file_path} ".schema --indent --nosys" > #{structure_file}))
               end
 
               # @api private
-              def load_command
-                raise Hanami::CLI::NotImplementedError
+              # @since 2.2.0
+              def exec_load_command
+                system_call.call("sqlite3 #{file_path} < #{structure_file}")
               end
 
               # @api private
+              # @since 2.2.0
+              def name
+                # Sequel expects sqlite:// URIs to operate the same as file:// URIs: 2 slashes for
+                # a relative path, 3 for an absolute path. In the case of 2 slashes, the first part
+                # of the path is considered by Ruby's `URI` as the `#host`.
+                @name ||= "#{database_uri.host}#{database_uri.path}"
+              end
+
+              private
+
               def file_path
-                @file_path ||= Pathname("#{root_path}#{config.uri.path}").realpath
+                @file_path ||= begin
+                  if File.absolute_path?(name)
+                    name
+                  else
+                    slice.app.root.join(name).to_s
+                  end
+                end
               end
             end
           end

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

@@ -1,24 +1,27 @@
 # frozen_string_literal: true
 
-require_relative "../../app/command"
-
 module Hanami
   module CLI
     module Commands
       module App
         module DB
           # @api private
-          class Version < App::Command
+          class Version < DB::Command
             desc "Print schema version"
 
-            option :target, desc: "Target migration number", aliases: ["-t"]
-
             # @api private
-            def call(target: nil, **) # rubocop:disable Lint/UnusedMethodArgument
-              migration = database.applied_migrations.last
-              version = migration ? File.basename(migration, ".*") : "not available"
+            def call(app: false, slice: nil, **)
+              databases(app: app, slice: slice).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"
+                  return
+                end
+
+                migration = database.applied_migrations.last
+                version = migration ? File.basename(migration, ".*") : "not available"
 
-              out.puts "=> current schema version is #{version}"
+                out.puts "=> #{database.name} current schema version is #{version}"
+              end
             end
           end
         end

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

@@ -32,13 +32,13 @@ module Hanami
             option \
               :skip_view,
               required: false,
-              type: :boolean,
+              type: :flag,
               default: DEFAULT_SKIP_VIEW,
               desc: "Skip view and template generation"
             option \
               :skip_tests,
               required: false,
-              type: :boolean,
+              type: :flag,
               default: DEFAULT_SKIP_TESTS,
               desc: "Skip test generation"
             option :slice, required: false, desc: "Slice name"
@@ -85,7 +85,8 @@ module Hanami
               skip_view: DEFAULT_SKIP_VIEW,
               skip_tests: DEFAULT_SKIP_TESTS, # rubocop:disable Lint/UnusedMethodArgument
               slice: nil,
-              context: nil, **
+              context: nil,
+              **
             )
               slice = inflector.underscore(Shellwords.shellescape(slice)) if slice
               name = naming.action_name(name)

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+require "dry/files"
+require "shellwords"
+require_relative "../../../naming"
+require_relative "../../../errors"
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        module Generate
+          # @since 2.2.0
+          # @api private
+          class Command < App::Command
+            option :slice, required: false, desc: "Slice name"
+
+            attr_reader :generator
+            private :generator
+
+            # @since 2.2.0
+            # @api private
+            def initialize(
+              fs:,
+              inflector:,
+              **opts
+            )
+              super
+              @generator = generator_class.new(fs: fs, inflector: inflector, out: out)
+            end
+
+            def generator_class
+              # Must be implemented by subclasses, with class that takes:
+              # fs:, inflector:, out:
+            end
+
+            # @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)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+require "dry/files"
+require "shellwords"
+module Hanami
+  module CLI
+    module Commands
+      module App
+        module Generate
+          # @api private
+          # @since 2.2.0
+          class Component < App::Command
+            argument :name, required: true, desc: "Component name"
+            option :slice, required: false, desc: "Slice name"
+
+            example [
+              %(operations.create_user               (MyApp::Operations::CreateUser)),
+              %(operations.user.create               (MyApp::Operations::Create::User)),
+              %(operations.create_user               --slice=admin (Admin::Operations::CreateUser)),
+              %(Operations::CreateUser               (MyApp::Operations::CreateUser)),
+            ]
+            attr_reader :generator
+            private :generator
+
+            # @api private
+            # @since 2.2.0
+            def initialize(
+              fs:, inflector:,
+              generator: Generators::App::Component.new(fs: fs, inflector: inflector),
+              **opts
+            )
+              @generator = generator
+              super(fs: fs, inflector: inflector, **opts)
+            end
+
+            # @api private
+            # @since 2.2.0
+            def call(name:, slice: nil, **)
+              slice = inflector.underscore(Shellwords.shellescape(slice)) if slice
+
+              generator.call(app.namespace, name, slice)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        module Generate
+          # @since 2.2.0
+          # @api private
+          class Migration < Command
+            argument :name, required: true, desc: "Migration name"
+
+            example [
+              %(create_posts),
+              %(add_published_at_to_posts),
+              %(create_users --slice=admin),
+            ]
+
+            def generator_class
+              Generators::App::Migration
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        module Generate
+          # @since 2.2.0
+          # @api private
+          class Operation < Command
+            argument :name, required: true, desc: "Operation name"
+
+            example [
+              %(books.add               (MyApp::Books::Add)),
+              %(books.add --slice=admin (Admin::Books::Add)),
+            ]
+
+            def generator_class
+              Generators::App::Operation
+            end
+          end
+        end
+      end
+    end
+  end
+end