hanami-cli 2.1.1 → 2.2.0.beta2

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

@@ -1,38 +1,39 @@
 # 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
-                end
-              else
-                out.puts "=> #{FILE_PATH} not found"
-              end
-            end
+            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 = []
 
-            private
+              databases(app: app, slice: slice).each do |database|
+                next if seeded_slices.include?(database.slice)
 
-            def full_file_path
-              File.join(app.root, FILE_PATH)
-            end
+                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
 
-            def has_file?
-              File.exist?(full_file_path)
+                seeded_slices << database.slice
+              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,40 @@ 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"
+
+              option :gateway, required: false, desc: "Use database for gateway"
 
               # @api private
-              def call(*)
-                measure("#{database.name} structure dumped to db/structure.sql") do
-                  database.dump_command
+              def call(app: false, slice: nil, gateway: nil, command_exit: method(:exit), **)
+                exit_codes = []
+
+                databases(app: app, slice: slice, gateway: gateway).each do |database|
+                  relative_structure_path = database.structure_file
+                    .relative_path_from(database.slice.app.root)
+
+                  measure("#{database.name} structure dumped to #{relative_structure_path}") do
+                    catch :dump_failed do
+                      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(database.structure_file, "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,54 @@
+# 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"
+
+              option :gateway, required: false, desc: "Use database for gateway"
+
+              # @api private
+              def call(app: false, slice: nil, gateway: nil, command_exit: method(:exit), **)
+                exit_codes = []
+
+                databases(app: app, slice: slice, gateway: gateway).each do |database|
+                  next unless database.structure_file.exist?
+
+                  relative_structure_path = database.structure_file
+                    .relative_path_from(database.slice.app.root)
+
+                  measure("#{database.name} structure loaded from #{relative_structure_path}") do
+                    catch :load_failed do
+                      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,11 @@ module Hanami
         module DB
           module Utils
             # @api private
+            # @since 2.2.0
             class Database
-              # @api private
-              attr_reader :app
-
-              # @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
@@ -30,88 +26,83 @@ module Hanami
                   require_relative("postgres")
                   Postgres
                 },
-                "mysql" => -> {
+                "mysql2" => -> {
                   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.database_class(database_url)
+                database_scheme = URI(database_url).scheme
+                DATABASE_CLASS_RESOLVER[database_scheme].call
+              end
 
-                resolver = SCHEME_MAP.fetch(config.db_type) do
-                  raise "#{config.db_type} is not a supported db scheme"
-                end
+              def self.from_slice(slice:, system_call:)
+                provider = slice.container.providers[:db]
+                raise "No :db provider for #{slice}" unless provider
 
-                klass = resolver.()
+                provider.source.database_urls.map { |(gateway_name, database_url)|
+                  database = database_class(database_url).new(
+                    slice: slice,
+                    gateway_name: gateway_name,
+                    system_call: system_call
+                  )
 
-                klass.new(app: app, config: config)
+                  [gateway_name, database]
+                }.to_h
               end
 
-              # @api private
-              def initialize(app:, config:)
-                @app = app
-                @config = config
+              attr_reader :slice
+              attr_reader :gateway_name
+
+              attr_reader :system_call
+
+              def initialize(slice:, gateway_name:, system_call:)
+                @slice = slice
+                @gateway_name = gateway_name
+                @system_call = system_call
               end
 
-              # @api private
-              def create_command
-                raise Hanami::CLI::NotImplementedError
+              def name
+                database_uri.path.sub(%r{^/}, "")
               end
 
-              # @api private
-              def drop_command
-                raise Hanami::CLI::NotImplementedError
+              def database_url
+                slice.container.providers[:db].source.database_urls.fetch(gateway_name)
               end
 
-              # @api private
-              def dump_command
-                raise Hanami::CLI::NotImplementedError
+              def database_uri
+                @database_uri ||= URI(database_url)
               end
 
-              # @api private
-              def load_command
-                raise Hanami::CLI::NotImplementedError
+              def gateway
+                slice["db.config"].gateways[gateway_name]
               end
 
-              # @api private
-              def root_path
-                app.root
+              def connection
+                gateway.connection
               end
 
-              # @api private
-              def rom_config
-                @rom_config ||=
-                  begin
-                    app.prepare(:persistence)
-                    app.container["persistence.config"]
-                  end
+              def exec_create_command
+                raise Hanami::CLI::NotImplementedError
               end
 
-              # @api private
-              def name
-                config.db_name
+              def exec_drop_command
+                raise Hanami::CLI::NotImplementedError
               end
 
-              # @api private
-              def gateway
-                rom_config.gateways[:default]
+              def exists?
+                raise Hanami::CLI::NotImplementedError
               end
 
-              # @api private
-              def connection
-                gateway.connection
+              def exec_dump_command
+                raise Hanami::CLI::NotImplementedError
+              end
+
+              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 +110,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 +133,47 @@ module Hanami
                 end
               end
 
+              def applied_migrations
+                sequel_migrator.applied_migrations
+              end
+
+              def db_config_path
+                slice.root.join("config", "db")
+              end
+
+              def db_config_dir?
+                db_config_path.directory?
+              end
+
               def migrations_path
-                File.join(root_path, "db/migrate")
+                if gateway_name == :default
+                  db_config_path.join("migrate")
+                else
+                  db_config_path.join("#{gateway_name}_migrate")
+                end
+              end
+
+              def migrations_dir?
+                migrations_path.directory?
+              end
+
+              def structure_file
+                path = slice.root.join("config", "db")
+
+                if gateway_name == :default
+                  path.join("structure.sql")
+                else
+                  path.join("#{gateway_name}_structure.sql")
+                end
+              end
+
+              def schema_migrations_sql_dump
+                return unless migrations_dir?
+
+                sql = +"INSERT INTO schema_migrations (filename) VALUES\n"
+                sql << applied_migrations.map { |v| "('#{v}')" }.join(",\n")
+                sql << ";"
+                sql
               end
             end
           end

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

@@ -11,18 +11,71 @@ module Hanami
             # @api private
             class Mysql < Database
               # @api private
-              def create_command
-                raise Hanami::CLI::NotImplementedError
+              def exec_create_command
+                return true if exists?
+
+                exec_cli("mysql", %(-e "CREATE DATABASE #{escaped_name}"))
+              end
+
+              # @api private
+              # @since 2.2.0
+              def exec_drop_command
+                return true unless exists?
+
+                exec_cli("mysql", %(-e "DROP DATABASE #{escaped_name}"))
+              end
+
+              # @api private
+              # @since 2.2.0
+              def exists?
+                result = exec_cli("mysql", %(-e "SHOW DATABASES LIKE '#{name}'" --batch))
+
+                result.successful? && result.out != ""
               end
 
               # @api private
-              def dump_command
-                raise Hanami::CLI::NotImplementedError
+              # @since 2.2.0
+              def exec_dump_command
+                exec_cli(
+                  "mysqldump",
+                  "--no-data --routines --skip-comments --result-file=#{structure_file} #{escaped_name}"
+                )
               end
 
               # @api private
-              def load_command
-                raise Hanami::CLI::NotImplementedError
+              # @since 2.2.0
+              def exec_load_command
+                exec_cli(
+                  "mysql",
+                  %(--execute "SET FOREIGN_KEY_CHECKS = 0; SOURCE #{structure_file}; SET FOREIGN_KEY_CHECKS = 1" --database #{escaped_name})
+                )
+              end
+
+              private
+
+              def escaped_name
+                Shellwords.escape(name)
+              end
+
+              def exec_cli(cli_name, cli_args)
+                system_call.call(
+                  "#{cli_name} #{cli_options} #{cli_args}",
+                  env: cli_env_vars
+                )
+              end
+
+              def cli_options
+                [].tap { |opts|
+                  opts << "--host=#{Shellwords.escape(database_uri.host)}" if database_uri.host
+                  opts << "--port=#{Shellwords.escape(database_uri.port)}" if database_uri.port
+                  opts << "--user=#{Shellwords.escape(database_uri.user)}" if database_uri.user
+                }.join(" ")
+              end
+
+              def cli_env_vars
+                @cli_env_vars ||= {}.tap do |vars|
+                  vars["MYSQL_PWD"] = database_uri.password.to_s if database_uri.password
+                end
               end
             end
           end

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

@@ -11,50 +11,71 @@ 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 schema_migrations_sql_dump
+                search_path = slice["db.gateway"].connection
+                  .fetch("SHOW search_path").to_a.first
+                  .fetch(:search_path)
+
+                +"SET search_path TO #{search_path};\n\n" << super
+              end
+
+              private
+
               def escaped_name
                 Shellwords.escape(name)
               end
 
-              # @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"
-              end
             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