snowpack 1.0.0.alpha2

data/lib/snowpack/cli/application/commands/db/create_migration.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "snowpack/cli/application/command"
+require_relative "structure/dump"
+require_relative "utils/database"
+
+module Snowpack
+  module CLI
+    module Application
+      module Commands
+        module DB
+          class CreateMigration < Command
+            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
+
+            private
+
+            def database
+              @database ||= Utils::Database.for_application(application)
+            end
+          end
+        end
+
+        register "db create_migration", DB::CreateMigration
+      end
+    end
+  end
+end

data/lib/snowpack/cli/application/commands/db/drop.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "snowpack/cli/application/command"
+require_relative "utils/database_config"
+
+module Snowpack
+  module CLI
+    module Application
+      module Commands
+        module DB
+          class Drop < Command
+            desc "Delete database"
+
+            def call(**)
+              db_name = database_config.db_name
+
+              system(database_config.cli_env_vars, "dropdb #{Shellwords.escape(db_name)}")
+              out.puts "=> database #{db_name} dropped" if $?.success?
+            end
+
+            private
+
+            def database_config
+              @database_config ||= Utils::DatabaseConfig.for_application(application)
+            end
+          end
+        end
+
+        register "db drop", Commands::DB::Drop
+      end
+    end
+  end
+end

data/lib/snowpack/cli/application/commands/db/migrate.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "snowpack/cli/application/command"
+require_relative "structure/dump"
+require_relative "utils/database"
+
+module Snowpack
+  module CLI
+    module Application
+      module Commands
+        module DB
+          class Migrate < Command
+            desc "Migrates database"
+
+            option :target, desc: "Target migration number", aliases: ["-t"]
+
+            def call(target: nil, **)
+              measure "database #{database.name} migrated" do
+                if target
+                  run_migrations(target: target)
+                else
+                  run_migrations
+                end
+              end
+
+              run_command Structure::Dump
+            end
+
+            private
+
+            def run_migrations(**options  )
+              ROM::SQL.with_gateway(database.gateway) do
+                database.migrator.run(options)
+              end
+            end
+
+            def database
+              @database ||= Utils::Database.for_application(application)
+            end
+          end
+        end
+
+        register "db migrate", DB::Migrate
+      end
+    end
+  end
+end

data/lib/snowpack/cli/application/commands/db/reset.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "snowpack/cli/application/command"
+require_relative "drop"
+require_relative "create"
+require_relative "migrate"
+
+module Snowpack
+  module CLI
+    module Application
+      module Commands
+        module DB
+          class Reset < Command
+            desc "Drop, create, and migrate database"
+
+            def call(**)
+              run_command Drop
+              run_command Create
+              run_command Migrate
+            end
+          end
+        end
+
+        register "db reset", Commands::DB::Reset
+      end
+    end
+  end
+end

data/lib/snowpack/cli/application/commands/db/rollback.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "snowpack/cli/application/command"
+require_relative "structure/dump"
+require_relative "utils/database"
+
+module Snowpack
+  module CLI
+    module Application
+      module Commands
+        module DB
+          class Rollback < Command
+            desc "Rollback database to a previous migration"
+
+            option :target, desc: "Target migration number", aliases: ["-t"]
+
+            def call(target: nil, **)
+              migration_code, migration_name = find_migration(target)
+
+              measure "database #{database.name} rolled back to #{migration_name}" do
+                database.gateway.run_migrations(target: Integer(migration_code))
+              end
+
+              run_command Structure::Dump
+            end
+
+            private
+
+            def database
+              @database ||= Utils::Database.for_application(application)
+            end
+
+            def find_migration(code)
+              migration = database.applied_migrations.yield_self { |migrations|
+                if code
+                  migrations.detect { |m| m.split("_").first == code }
+                else
+                  migrations.last
+                end
+              }
+
+              migration_code = code || migration.split("_").first
+              migration_name = File.basename(migration, ".*")
+
+              [migration_code, migration_name]
+            end
+          end
+        end
+
+        register "db rollback", Commands::DB::Rollback
+      end
+    end
+  end
+end

data/lib/snowpack/cli/application/commands/db/sample_data.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "snowpack/cli/application/command"
+require_relative "structure/dump"
+
+module Snowpack
+  module CLI
+    module Application
+      module Commands
+        module DB
+          class SampleData < Command
+            desc "Load sample data"
+
+            def call(**)
+              if has_file?
+                measure "Sample data loaded" do
+                  application.boot!
+                  load file_path
+                end
+              else
+                out.puts "=> no sample data available"
+              end
+            end
+
+            private
+
+            def file_path
+              File.join(application.root, "db/sample_data.rb")
+            end
+
+            def has_file?
+              File.exist?(file_path)
+            end
+          end
+        end
+
+        register "db sample_data", DB::SampleData
+      end
+    end
+  end
+end

data/lib/snowpack/cli/application/commands/db/seed.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "snowpack/cli/application/command"
+require_relative "structure/dump"
+
+module Snowpack
+  module CLI
+    module Application
+      module Commands
+        module DB
+          class Seed < Command
+            desc "Load database seeds"
+
+            def call(**)
+              if has_file?
+                measure "Database seeds loaded" do
+                  application.boot
+                  load file_path
+                end
+              else
+                out.puts "=> no database seeds available"
+              end
+            end
+
+            private
+
+            def file_path
+              File.join(application.root, "db/seed.rb")
+            end
+
+            def has_file?
+              File.exist?(seeds_path)
+            end
+          end
+        end
+
+        register "db seed", DB::Seed
+      end
+    end
+  end
+end

data/lib/snowpack/cli/application/commands/db/structure/dump.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "snowpack/cli/application/command"
+
+module Snowpack
+  module CLI
+    module Application
+      module Commands
+        module DB
+          module Structure
+            class Dump < Command
+              desc "Dumps database structure to db/structure.sql file"
+
+              def call(*)
+                measure("#{database_config.db_name} structure dumped to db/structure.sql") do
+                  cmd = "pg_dump --schema-only --no-owner #{Shellwords.escape(database_config.db_name)} > #{output_file}"
+                  system(database_config.cli_env_vars, cmd)
+                end
+              end
+
+              private
+
+              def database_config
+                @database_config ||= Utils::DatabaseConfig.for_application(application)
+              end
+
+              def output_file
+                "#{application.root}/db/structure.sql"
+              end
+            end
+          end
+        end
+
+        register "db structure dump", DB::Structure::Dump
+      end
+    end
+  end
+end

data/lib/snowpack/cli/application/commands/db/utils/database.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "hanami/cli"
+require "snowpack/cli/command"
+
+module Snowpack
+  module CLI
+    module Application
+      module Commands
+        module DB
+          module Utils
+            class Database
+              def self.for_application(application)
+                application.init :persistence
+
+                new(
+                  config: application["persistence.config"],
+                  root_path: application.root,
+                )
+              end
+
+              attr_reader :config
+              attr_reader :root_path
+
+              def initialize(config:, root_path:)
+                @config = config
+                @root_path = root_path
+              end
+
+              def url
+                gateway.connection.url
+              end
+
+              def name
+                url.split("/").last
+              end
+
+              def applied_migrations
+                sequel_migrator.applied_migrations
+              end
+
+              def gateway
+                config.gateways[:default]
+              end
+
+              def connection
+                gateway.connection
+              end
+
+              def migrator
+                @migrator ||= ROM::SQL::Migration::Migrator.new(
+                  connection,
+                  path: File.join(root_path, "db/migrate"),
+                )
+              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(application.root, "db/migrate")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/snowpack/cli/application/commands/db/utils/database_config.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "hanami/cli"
+require "uri"
+
+module Snowpack
+  module CLI
+    module Application
+      module Commands
+        module DB
+          module Utils
+            class DatabaseConfig
+              def self.for_application(application)
+                new(application[:settings].database_url)
+              end
+
+              attr_reader :url
+
+              def initialize(database_url)
+                @url = database_url
+              end
+
+              def uri
+                @uri ||= URI.parse(url)
+              end
+
+              def hostname
+                uri.hostname
+              end
+
+              def db_name
+                @db_name ||= uri.path.gsub(/^\//, '')
+              end
+
+              def cli_env_vars
+                @cli_env_vars ||= {}.tap do |vars|
+                  vars["PGHOST"] = uri.host.to_s
+                  vars["PGPORT"] = uri.port.to_s if uri.port
+                  vars["PGUSER"] = uri.user.to_s if uri.user
+                  vars["PGPASSWORD"] = uri.password.to_s if uri.password
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/snowpack/cli/application/commands/db/version.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "hanami/cli"
+require "snowpack/cli/application/command"
+require_relative "structure/dump"
+require_relative "utils/database"
+
+module Snowpack
+  module CLI
+    module Application
+      module Commands
+        module DB
+          class Version < Command
+            desc "Print schema version"
+
+            option :target, desc: "Target migration number", aliases: ["-t"]
+
+            def call(target: nil, **)
+              migration = database.applied_migrations.last
+              version = migration ? File.basename(migration, ".*") : "not available"
+
+              out.puts "=> current schema version is #{version}"
+            end
+
+            private
+
+            def database
+              @database ||= Utils::Database.for_application(application)
+            end
+          end
+        end
+
+        register "db version", DB::Version
+      end
+    end
+  end
+end

data/lib/snowpack/cli/application/commands/generate/slice.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "snowpack/cli/application/command"
+require "snowpack/generators/slice/generator"
+
+module Snowpack
+  module CLI
+    module Application
+      module Commands
+        module Generate
+          class Slice < Command
+            desc "Generate slice"
+
+            argument :name, desc: "Name for the slice"
+            option :web, type: :boolean, default: true, desc: "Include web routing and views support in generated slice"
+
+            def call(name:, web:, **)
+              name ||= path
+
+              # TODO raise ArgumentError, "invalid name blah blah"
+
+              generator = Generators::Slice::Generator.new
+              generator.(application: application, slice_name: name, web: web)
+            end
+          end
+        end
+
+        register "generate slice", Generate::Slice
+      end
+    end
+  end
+end

data/lib/snowpack/cli/application/commands/routes/update.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "snowpack/cli/application/command"
+
+module Snowpack
+  module CLI
+    module Application
+      module Commands
+        module Routes
+          class Update < Command
+            desc "Update Roda routes.json"
+
+            def call(**)
+              measure "routes.json updated" do
+                `bundle exec roda-parse_routes #{route_files} -f #{routes_json_file}`
+              end
+            end
+
+            private
+
+            def route_files
+              Dir["#{application.root}/apps/**/web/routes/**/*.rb"].join(" ")
+            end
+
+            def routes_json_file
+              "#{application.root}/config/routes.json"
+            end
+          end
+        end
+
+        register "routes update", Routes::Update
+      end
+    end
+  end
+end

data/lib/snowpack/cli/application/commands.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Snowpack
+  module CLI
+    module Application
+      module Commands
+        extend Hanami::CLI::Registry
+
+        require_relative "commands/assets/clobber"
+        require_relative "commands/assets/compile"
+        require_relative "commands/console"
+        require_relative "commands/generate/slice"
+        require_relative "commands/db/create"
+        require_relative "commands/db/create_migration"
+        require_relative "commands/db/drop"
+        require_relative "commands/db/migrate"
+        require_relative "commands/db/reset"
+        require_relative "commands/db/rollback"
+        require_relative "commands/db/sample_data"
+        require_relative "commands/db/seed"
+        require_relative "commands/db/structure/dump"
+        require_relative "commands/db/version"
+        require_relative "commands/routes/update"
+      end
+    end
+  end
+end

data/lib/snowpack/cli/command.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+require "hanami/cli/command"
+require "hanami/utils/files"
+
+module Snowpack
+  module CLI
+    class Command < Hanami::CLI::Command
+      attr_reader :out
+      attr_reader :inflector
+      attr_reader :files
+
+      # TODO: consider injecting `out, files` from level of Snowpack::CLI?
+      def initialize(
+        command_name:,
+        out: $stdout,
+        inflector: Dry::Inflector.new,
+        files: Hanami::Utils::Files
+      )
+        super(command_name: command_name)
+
+        @out = out
+        @inflector = inflector
+        @files = files
+      end
+
+      private
+
+      def run_command(klass, *args)
+        klass.new(
+          command_name: klass.name,
+          application: application,
+          out: out,
+          files: files,
+        ).call(*args)
+      end
+
+      def measure(desc, &block)
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        block.call
+        stop = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        out.puts "=> #{desc} in #{(stop - start).round(1)}s"
+      end
+    end
+  end
+end

data/lib/snowpack/cli/standalone/cli.rb

@@ -0,0 +1,14 @@
+require "hanami/cli"
+require_relative "commands"
+
+module Snowpack
+  module CLI
+    module Standalone
+      class CLI < Hanami::CLI
+        def initialize(commands = Commands)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/snowpack/cli/standalone/commands/new.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "snowpack/cli/command"
+require "snowpack/generators/application/generator"
+
+module Snowpack
+  module CLI
+    module Standalone
+      module Commands
+        class New < Command
+          argument :path, desc: "Path for new application"
+          option :name, desc: "Name for the application"
+
+          def call(path:, name: nil, **)
+            name ||= path
+
+            # TODO raise ArgumentError, "invalid name application"
+
+            out.puts "Generating into #{path}..."
+
+            generator = Generators::Application::Generator.new
+            generator.(path, name)
+
+            out.puts "Bootstrapping..."
+            system "#{path}/script/bootstrap"
+          end
+        end
+
+        register "new", New
+      end
+    end
+  end
+end