hanami-cli 1.0.0.alpha1 → 2.0.0.alpha6

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative "database_config"
+
+module Hanami
+  module CLI
+    module Commands
+      module DB
+        module Utils
+          class Database
+            attr_reader :application, :config
+
+            SCHEME_MAP = {
+              "sqlite" => -> {
+                require_relative("sqlite")
+                Sqlite
+              },
+              "postgres" => -> {
+                require_relative("postgres")
+                Postgres
+              },
+              "postgresql" => -> {
+                require_relative("postgres")
+                Postgres
+              },
+              "mysql" => -> {
+                require_relative("mysql")
+                Mysql
+              }
+            }.freeze
+
+            def self.[](application)
+              config = DatabaseConfig.new(application.settings.database_url)
+
+              resolver = SCHEME_MAP.fetch(config.db_type) do
+                raise "#{config.db_type} is not a supported db scheme"
+              end
+
+              klass = resolver.()
+
+              klass.new(application: application, config: config)
+            end
+
+            def initialize(application:, config:)
+              @application = application
+              @config = config
+            end
+
+            def create_command
+              raise NotImplementedError
+            end
+
+            def drop_command
+              raise NotImplementedError
+            end
+
+            def dump_command
+              raise NotImplementedError
+            end
+
+            def load_command
+              raise NotImplementedError
+            end
+
+            def root_path
+              application.root
+            end
+
+            def rom_config
+              @rom_config ||=
+                begin
+                  application.init_bootable(:persistence)
+                  application.container["persistence.config"]
+                end
+            end
+
+            def name
+              config.db_name
+            end
+
+            def gateway
+              rom_config.gateways[:default]
+            end
+
+            def connection
+              gateway.connection
+            end
+
+            def run_migrations(**options)
+              require "rom/sql"
+              ROM::SQL.with_gateway(gateway) do
+                migrator.run(options)
+              end
+            end
+
+            def migrator
+              @migrator ||=
+                begin
+                  require "rom/sql"
+                  ROM::SQL::Migration::Migrator.new(connection, path: File.join(root_path, "db/migrate"))
+                end
+            end
+
+            def applied_migrations
+              sequel_migrator.applied_migrations
+            end
+
+            private
+
+            def sequel_migrator
+              Sequel::TimestampMigrator.new(migrator.connection, migrations_path, {})
+            end
+
+            def migrations_path
+              File.join(root_path, "db/migrate")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/db/utils/database_config.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Hanami
+  module CLI
+    module Commands
+      module DB
+        module Utils
+          class DatabaseConfig
+            attr_reader :uri
+
+            def initialize(database_url)
+              @uri = URI(database_url)
+            end
+
+            def hostname
+              uri.hostname
+            end
+            alias_method :host, :hostname
+
+            def user
+              uri.user
+            end
+            alias_method :username, :user
+
+            def password
+              uri.password
+            end
+            alias_method :pass, :password
+
+            def port
+              uri.port
+            end
+
+            def db_name
+              @db_name ||= uri.path.gsub(/\A\//, "")
+            end
+
+            def db_type
+              uri.scheme
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "database"
+
+module Hanami
+  module CLI
+    module Commands
+      module DB
+        module Utils
+          class Mysql < Database
+            def create_command
+              raise "Not Implemented Yet"
+            end
+
+            def dump_command
+              raise "Not Implemented Yet"
+            end
+
+            def load_command
+              raise "Not Implemented Yet"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require_relative "database"
+
+module Hanami
+  module CLI
+    module Commands
+      module DB
+        module Utils
+          class Postgres < Database
+            def create_command
+              system(cli_env_vars, "createdb #{escaped_name}")
+            end
+
+            def drop_command
+              system(cli_env_vars, "dropdb #{escaped_name}")
+            end
+
+            def dump_command
+              system(cli_env_vars, "pg_dump --schema-only --no-owner #{escaped_name} > #{dump_file}")
+            end
+
+            def load_command
+              raise "Not Implemented Yet"
+            end
+
+            def escaped_name
+              Shellwords.escape(name)
+            end
+
+            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
+              end
+            end
+
+            def dump_file
+              "#{root_path}/db/structure.sql"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "database"
+
+module Hanami
+  module CLI
+    module Commands
+      module DB
+        module Utils
+          class Sqlite < Database
+            def create_command
+              rom_config
+              true
+            end
+
+            def drop_command
+              file_path.unlink
+              true
+            end
+
+            def dump_command
+              raise "Not Implemented Yet"
+            end
+
+            def load_command
+              raise "Not Implemented Yet"
+            end
+
+            def file_path
+              @file_path ||= Pathname("#{root_path}#{config.uri.path}").realpath
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/gem/new.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "hanami/cli/command"
+require "hanami/cli/bundler"
+require "hanami/cli/command_line"
+require "hanami/cli/generators/gem/application"
+require "dry/files"
+
+module Hanami
+  module CLI
+    module Commands
+      module Gem
+        class New < Command
+          ARCHITECTURES = %w[monolith micro].freeze
+          private_constant :ARCHITECTURES
+
+          DEFAULT_ARCHITECTURE = ARCHITECTURES.first
+          private_constant :DEFAULT_ARCHITECTURE
+
+          DEFAULT_SLICE_NAME = "main"
+          private_constant :DEFAULT_SLICE_NAME
+
+          DEFAULT_SLICE_URL_PREFIX = "/"
+          private_constant :DEFAULT_SLICE_URL_PREFIX
+
+          argument :app, required: true, desc: "The application name"
+
+          option :architecture, alias: "arch", default: DEFAULT_ARCHITECTURE,
+                                values: ARCHITECTURES, desc: "The architecture"
+
+          option :slice, default: DEFAULT_SLICE_NAME, desc: %(The initial slice name, only for "monolith" architecture)
+          option :slice_url_prefix, default: DEFAULT_SLICE_URL_PREFIX,
+                                    desc: %(The initial slice URL prefix, only for "monolith" architecture)
+
+          def initialize(fs: Dry::Files.new, bundler: CLI::Bundler.new(fs: fs),
+                         command_line: CLI::CommandLine.new(bundler: bundler), **other)
+            @bundler = bundler
+            @command_line = command_line
+            super(fs: fs, **other)
+          end
+
+          def call(app:, architecture: DEFAULT_ARCHITECTURE, slice: DEFAULT_SLICE_NAME,
+                   slice_url_prefix: DEFAULT_SLICE_URL_PREFIX, **)
+            app = inflector.underscore(app)
+
+            fs.mkdir(app)
+            fs.chdir(app) do
+              generator(architecture).call(app, slice, slice_url_prefix) do
+                bundler.install!
+                run_install_commmand!
+              end
+            end
+          end
+
+          private
+
+          attr_reader :bundler
+          attr_reader :command_line
+
+          def generator(architecture)
+            unless ARCHITECTURES.include?(architecture)
+              raise ArgumentError.new("unknown architecture `#{architecture}'")
+            end
+
+            Generators::Gem::Application[architecture, fs, inflector, command_line]
+          end
+
+          def run_install_commmand!
+            command_line.call("hanami install").tap do |result|
+              raise "hanami install failed\n\n\n#{result.err.inspect}" unless result.successful?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/gem/version.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "hanami/cli/command"
+
+module Hanami
+  module CLI
+    module Commands
+      module Gem
+        class Version < Command
+          def call(*)
+            require "hanami/version"
+            out.puts "v#{Hanami::VERSION}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/gem.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    module Commands
+      module Gem
+        require_relative "gem/version"
+        # FIXME: temporary disabled for Hanami v2.0.0.alpha2
+        # require_relative "gem/new"
+
+        def self.extended(base)
+          base.module_eval do
+            register "version", Version, aliases: ["v", "-v", "--version"]
+            # FIXME: temporary disabled for Hanami v2.0.0.alpha2
+            # register "new", New
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "hanami/console/context"
+
+require_relative "../application"
+
+module Hanami
+  module CLI
+    module Commands
+      module Monolith
+        # @api public
+        class Console < Application
+          REPLS = {
+            "pry" => -> (*args) {
+              begin
+                require "hanami/cli/repl/pry"
+                Repl::Pry.new(*args)
+              rescue LoadError; end # rubocop:disable Lint/SuppressedException
+            },
+            "irb" => -> (*args) {
+              require "hanami/cli/repl/irb"
+              Repl::Irb.new(*args)
+            },
+          }.freeze
+
+          desc "Application REPL"
+
+          option :repl, required: false, desc: "REPL gem that should be used ('pry' or 'irb')"
+
+          # @api private
+          def call(repl: nil, **opts)
+            engine = resolve_engine(repl, opts)
+            engine.start
+          end
+
+          private
+
+          def resolve_engine(repl, opts)
+            if repl
+              REPLS.fetch(repl).(application, opts)
+            else
+              REPLS.map { |(_, loader)| loader.(application, opts) }.compact.first
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../../application"
+
+module Hanami
+  module CLI
+    module Commands
+      module Monolith
+        module DB
+          class Create < Application
+            desc "Create database"
+
+            def call(**)
+              if database.create_command
+                out.puts "=> database #{database.name} created"
+              else
+                out.puts "=> failed to create database #{database.name}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/monolith/db/create_migration.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../../application"
+require_relative "structure/dump"
+
+module Hanami
+  module CLI
+    module Commands
+      module Monolith
+        module DB
+          class CreateMigration < Application
+            desc "Create new migration file"
+
+            argument :name, desc: "Migration file name"
+
+            def call(name:, **)
+              migrator = database.migrator
+              version = migrator.generate_version
+
+              measure "migration #{version}_#{name} created" do
+                migrator.create_file(name, version)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../../application"
+
+module Hanami
+  module CLI
+    module Commands
+      module Monolith
+        module DB
+          class Drop < Application
+            desc "Delete database"
+
+            def call(**)
+              if database.drop_command
+                out.puts "=> database #{database.name} dropped"
+              else
+                out.puts "=> failed to drop #{database.name}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../../application"
+require_relative "structure/dump"
+
+module Hanami
+  module CLI
+    module Commands
+      module Monolith
+        module DB
+          class Migrate < Application
+            desc "Migrates database"
+
+            option :target, desc: "Target migration number", aliases: ["-t"]
+
+            def call(target: nil, **)
+              return true if Dir[File.join(application.root, "db/migrate/*.rb")].empty?
+
+              measure "database #{database.name} migrated" do
+                if target
+                  run_migrations(target: Integer(target))
+                else
+                  run_migrations
+                end
+
+                true
+              end
+            end
+
+            private
+
+            def run_migrations(**options)
+              database.run_migrations(**options)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/monolith/db/reset.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../../application"
+require_relative "create"
+require_relative "drop"
+require_relative "migrate"
+
+module Hanami
+  module CLI
+    module Commands
+      module Monolith
+        module DB
+          class Reset < Application
+            desc "Drop, create, and migrate database"
+
+            def call(**)
+              run_command Drop
+              run_command Create
+              run_command Migrate
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/monolith/db/rollback.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../../application"
+require_relative "structure/dump"
+
+module Hanami
+  module CLI
+    module Commands
+      module Monolith
+        module DB
+          class Rollback < Application
+            desc "Rollback database to a previous migration"
+
+            option :target, desc: "Target migration number", aliases: ["-t"]
+            option :dump, desc: "Dump structure after rolling back"
+
+            def call(target: nil, dump: true, **)
+              migration_code, migration_name = find_migration(target)
+
+              if migration_name.nil?
+                out.puts "==> migration file for target #{target} was not found"
+                return
+              end
+
+              measure "database #{database.name} rolled back to #{migration_name}" do
+                database.run_migrations(target: Integer(migration_code))
+              end
+
+              run_command Structure::Dump if dump
+            end
+
+            private
+
+            def find_migration(code)
+              migration = database.applied_migrations.yield_self { |migrations|
+                if code
+                  migrations.detect { |m| m.split("_").first == code }
+                else
+                  migrations.last
+                end
+              }
+
+              return unless migration
+
+              migration_code = code || migration.split("_").first
+              migration_name = File.basename(migration, ".*")
+
+              [migration_code, migration_name]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/monolith/db/sample_data.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../../application"
+require_relative "structure/dump"
+
+module Hanami
+  module CLI
+    module Commands
+      module Monolith
+        module DB
+          class SampleData < Application
+            FILE_PATH = "db/sample_data.rb"
+
+            desc "Load sample data"
+
+            def call(**)
+              if has_file?
+                measure "sample data loaded from #{FILE_PATH}" do
+                  load full_file_path
+                end
+              else
+                out.puts "=> #{FILE_PATH} not found"
+              end
+            end
+
+            private
+
+            def full_file_path
+              File.join(application.root, FILE_PATH)
+            end
+
+            def has_file?
+              File.exist?(full_file_path)
+            end
+          end
+        end
+      end
+    end
+  end
+end