rivulet-rb 0.1.0

data/lib/rivulet/cli/generate/service/operation.rb

@@ -0,0 +1,118 @@
+require 'fileutils'
+
+module Rivulet
+  module CLI
+    module Commands
+      module Generate
+        class Service
+          class Operation < Dry::CLI::Command
+            desc "Generate an operation"
+            argument :name, required: true, desc: "Operation name in service.operation format (e.g. users.create)"
+
+            def call(name:, **)
+              service_name, operation_name = name.split('.')
+              service_dir      = underscore(service_name)
+              operation_dir    = underscore(operation_name)
+              service_module   = camelize(service_dir)
+              operation_module = camelize(operation_dir)
+              base             = "app/services/#{service_dir}"
+
+              mkdir "#{base}/projections"
+              write "#{base}/operations/#{operation_dir}.rb", operation_template(service_module, operation_module)
+              write "#{base}/contracts/#{operation_dir}.rb",  contract_template(service_module, operation_module)
+              register_operation(base, service_dir, service_module, operation_dir, operation_module)
+            end
+
+            private
+
+            def underscore(str)
+              str
+                .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                .downcase
+            end
+
+            def camelize(str)
+              str.split('_').map(&:capitalize).join
+            end
+
+            def mkdir(path)
+              Dir.mkdir(path) unless Dir.exist?(path)
+            end
+
+            def write(path, content)
+              File.write(path, content)
+              puts "  create  #{path}"
+            end
+
+            def operation_template(service_module, operation_module)
+              <<~RUBY
+                module Services
+                  module #{service_module}
+                    module Operations
+                      class #{operation_module} < Rivulet::Operation
+                        def call(input = {})
+                        end
+                      end
+                    end
+                  end
+                end
+              RUBY
+            end
+
+            def contract_template(service_module, operation_module)
+              <<~RUBY
+                module Services
+                  module #{service_module}
+                    module Contracts
+                      class #{operation_module} < ApplicationContract
+                        params do
+                        end
+                      end
+                    end
+                  end
+                end
+              RUBY
+            end
+
+            def register_operation(base, service_dir, service_module, operation_dir, operation_module)
+              container_file       = "#{base}/container.rb"
+              op_registration      = "        register('#{operation_dir}') { Services::#{service_module}::Operations::#{operation_module}.new }\n"
+              contract_registration = "        register('#{operation_dir}') { Services::#{service_module}::Contracts::#{operation_module}.new }\n"
+
+              if File.exist?(container_file)
+                content = File.read(container_file)
+                content.sub!(/(      namespace\('operations'\) do\n)/, "\\1#{op_registration}")
+                content.sub!(/(      namespace\('contracts'\) do\n)/, "\\1#{contract_registration}")
+                File.write(container_file, content)
+                puts "  update  #{container_file}"
+              else
+                write container_file, container_template(service_module, operation_dir, operation_module)
+              end
+            end
+
+            def container_template(service_module, operation_dir, operation_module)
+              <<~RUBY
+                module Services
+                  module #{service_module}
+                    class Container
+                      extend Dry::Core::Container::Mixin
+
+                      namespace('operations') do
+                        register('#{operation_dir}') { Services::#{service_module}::Operations::#{operation_module}.new }
+                      end
+
+                      namespace('contracts') do
+                        register('#{operation_dir}') { Services::#{service_module}::Contracts::#{operation_module}.new }
+                      end
+                    end
+                  end
+                end
+              RUBY
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rivulet/cli/generate/service/projection.rb

@@ -0,0 +1,89 @@
+require 'fileutils'
+
+module Rivulet
+  module CLI
+    module Commands
+      module Generate
+        class Service
+          class Projection < Dry::CLI::Command
+            desc "Generate a projection"
+            argument :name, required: true, desc: "Step name in service.projection format (e.g. users.common)"
+
+            def call(name:, **)
+              service_name, step_name = name.split('.')
+              service_dir      = underscore(service_name)
+              projection_dir   = underscore(step_name)
+              service_module   = camelize(service_dir)
+              projection_class = camelize(projection_dir)
+              base             = "app/services/#{service_dir}"
+
+              write "#{base}/projections/#{projection_dir}.rb", projection_template(service_module, projection_class)
+              register_projection(base, service_module, projection_dir, projection_class)
+            end
+
+            private
+
+            def underscore(str)
+              str
+                .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                .downcase
+            end
+
+            def camelize(str)
+              str.split('_').map(&:capitalize).join
+            end
+
+            def write(path, content)
+              File.write(path, content)
+              puts "  create  #{path}"
+            end
+
+            def projection_template(service_module, projection_class)
+              <<~RUBY
+                module Services
+                  module #{service_module}
+                    module Projections
+                      class #{projection_class} < Rivulet::Projection
+                      end
+                    end
+                  end
+                end
+              RUBY
+            end
+
+            def register_projection(base, service_module, projection_name, projection_class)
+              container_file          = "#{base}/container.rb"
+              projection_registration = "        register('#{projection_name}') { Services::#{service_module}::Projections::#{projection_class}.new }\n"
+
+              if File.exist?(container_file)
+                content = File.read(container_file)
+                content.sub!(/(      namespace\('projections'\) do\n)/, "\\1#{projection_registration}")
+                File.write(container_file, content)
+                puts "  update  #{container_file}"
+              else
+                write container_file, container_template(service_module, projection_name, projection_class)
+              end
+            end
+
+            def container_template(service_module, projection_name, projection_class)
+              <<~RUBY
+                module Services
+                  module #{service_module}
+                    class Container
+                      extend Dry::Core::Container::Mixin
+
+                      namespace('projections') do
+                        register('#{projection_name}') { Services::#{service_module}::Projections::#{projection_class}.new }
+                      end
+                    end
+                  end
+                end
+              RUBY
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rivulet/cli/generate/service/step.rb

@@ -0,0 +1,91 @@
+require 'fileutils'
+
+module Rivulet
+  module CLI
+    module Commands
+      module Generate
+        class Service
+          class Step < Dry::CLI::Command
+            desc "Generate a step"
+            argument :name, required: true, desc: "Step name in service.step format (e.g. users.create)"
+
+            def call(name:, **)
+              service_name, step_name = name.split('.')
+              service_dir    = underscore(service_name)
+              step_dir       = underscore(step_name)
+              service_module = camelize(service_dir)
+              step_class     = camelize(step_dir)
+              base           = "app/services/#{service_dir}"
+
+              write "#{base}/steps/#{step_dir}.rb", step_template(service_module, step_class)
+              register_step(base, service_module, step_dir, step_class)
+            end
+
+            private
+
+            def underscore(str)
+              str
+                .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                .downcase
+            end
+
+            def camelize(str)
+              str.split('_').map(&:capitalize).join
+            end
+
+            def write(path, content)
+              File.write(path, content)
+              puts "  create  #{path}"
+            end
+
+            def step_template(service_module, step_class)
+              <<~RUBY
+                module Services
+                  module #{service_module}
+                    module Steps
+                      class #{step_class} < Rivulet::Step
+                        def call(input)
+                        end
+                      end
+                    end
+                  end
+                end
+              RUBY
+            end
+
+            def register_step(base, service_module, step_name, step_class)
+              container_file       = "#{base}/container.rb"
+              step_registration      = "        register('#{step_name}') { Services::#{service_module}::Steps::#{step_class}.new }\n"
+
+              if File.exist?(container_file)
+                content = File.read(container_file)
+                content.sub!(/(      namespace\('steps'\) do\n)/, "\\1#{step_registration}")
+                File.write(container_file, content)
+                puts "  update  #{container_file}"
+              else
+                write container_file, container_template(service_module, step_name, step_class)
+              end
+            end
+
+            def container_template(service_module, step_name, step_class)
+              <<~RUBY
+                module Services
+                  module #{service_module}
+                    class Container
+                      extend Dry::Core::Container::Mixin
+
+                      namespace('steps') do
+                        register('#{step_name}') { Services::#{service_module}::Steps::#{step_class}.new }
+                      end
+                    end
+                  end
+                end
+              RUBY
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rivulet/cli/generate/service.rb

@@ -0,0 +1,143 @@
+require 'dry/inflector'
+require 'fileutils'
+
+module Rivulet
+  module CLI
+    module Commands
+      module Generate
+        class Service < Dry::CLI::Command
+          desc "Generate a service"
+          argument :name, required: true, desc: "Service name (e.g. Users or users)"
+
+          option :create, type: :boolean, aliases: ['-c'], desc: 'Add "create" operation'
+          option :read,   type: :boolean, aliases: ['-r'], desc: 'Add "get" operation'
+          option :update, type: :boolean, aliases: ['-u'], desc: 'Add "update" operation'
+          option :delete, type: :boolean, aliases: ['-d'], desc: 'Add "delete" operation'
+          option :list,   type: :boolean, aliases: ['-l'], desc: 'Add "list" operation'
+
+          SUBDIRS = %w[contracts operations steps].freeze
+
+          def call(name:, **options)
+            dir_name      = underscore(name)
+            module_name   = camelize(dir_name)
+            base          = "app/services/#{dir_name}"
+            singular_name = Dry::Inflector.new.singularize(name)
+
+            SUBDIRS.each { |d| create_dir "#{base}/#{d}" }
+            write "#{base}/service.rb", service_template(module_name)
+            create_container(base, module_name) unless File.exist?("#{base}/container.rb")
+            register_service(dir_name, module_name)
+
+            if options[:create]
+              Operation.new.call(name: "#{name}.create_#{singular_name}")
+            end
+
+            if options[:read]
+              Operation.new.call(name: "#{name}.get_#{singular_name}")
+            end
+
+            if options[:update]
+              Operation.new.call(name: "#{name}.update_#{singular_name}")
+            end
+
+            if options[:delete]
+              Operation.new.call(name: "#{name}.delete_#{singular_name}")
+            end
+
+            if options[:list]
+              Operation.new.call(name: "#{name}.list_#{name}")
+            end
+          end
+
+          private
+
+          def underscore(str)
+            str
+              .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+              .downcase
+          end
+
+          def camelize(str)
+            str.split('_').map(&:capitalize).join
+          end
+
+          def create_dir(path)
+            FileUtils.mkdir_p(path)
+            puts "  create  #{path}/"
+          end
+
+          def create_container(base, module_name)
+            write "#{base}/container.rb", container_template(module_name)
+          end
+
+          def write(path, content)
+            File.write(path, content)
+            puts "  create  #{path}"
+          end
+
+          def service_template(module_name)
+            <<~RUBY
+              module Services
+                module #{module_name}
+                  class Service
+                    NAMESPACE = 'operations'
+
+                    def method_missing(name, input = {}, options = {}, &block)
+                      key = [NAMESPACE, name].join('.')
+                      super unless Container.key?(key)
+
+                      Container[key].call(input, **options, &block)
+                    end
+
+                    def respond_to_missing?(name, include_private = false)
+                      key = [NAMESPACE, name].join('.')
+                      Container.key?(key) || super
+                    end
+                  end
+                end
+              end
+            RUBY
+          end
+
+          def container_template(module_name)
+            <<~RUBY
+              module Services
+                module #{module_name}
+                  class Container
+                    extend Dry::Core::Container::Mixin
+                    import Services::Shared::Namespace
+
+                    namespace('operations') do
+                    end
+
+                    namespace('steps') do
+                    end
+
+                    namespace('contracts') do
+                    end
+
+                    namespace('projections') do
+                    end
+                  end
+                end
+              end
+            RUBY
+          end
+
+          def register_service(dir_name, module_name)
+            services_file = 'app/services.rb'
+            return unless File.exist?(services_file)
+
+            content      = File.read(services_file)
+            registration = "  register('#{dir_name}') { Services::#{module_name}::Service.new }\n"
+
+            updated = content.sub(/^end\s*\z/, "#{registration}end\n")
+            File.write(services_file, updated)
+            puts "  update  #{services_file}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rivulet/cli/new.rb

@@ -0,0 +1,191 @@
+require 'fileutils'
+
+module Rivulet
+  module CLI
+    module Commands
+      class New < Dry::CLI::Command
+        desc "Create a new Rivulet application"
+        argument :name, required: true, desc: "Application name"
+
+        DIRS = %w[
+          app/handlers
+          app/handlers/shared
+          app/handlers/shared/steps
+          app/handlers/shared/utils
+          app/services
+          app/services/shared
+          app/services/shared/steps
+          app/services/shared/utils
+          app/models
+          config
+          db/migrations
+        ].freeze
+
+        def call(name:, **)
+          DIRS.each { |d| create_dir "#{name}/#{d}" }
+
+          write name, 'Gemfile',                    gemfile
+          write name, 'config.ru',                 config_ru
+          write name, 'config/application.rb',     application_config(name)
+          write name, 'config/routes.rb',          routes_config
+          write name, 'falcon.rb',                   falcon_config
+          write name, 'app/handlers.rb', handlers_container
+          write name, 'app/handlers/shared/container.rb', handlers_shared_container
+          write name, 'app/handlers/shared/namespace.rb', handlers_shared_namespace
+          write name, 'app/services.rb', services_container
+          write name, 'app/services/shared/container.rb', services_shared_container
+          write name, 'app/services/shared/namespace.rb', services_shared_namespace
+          write name, 'app/application_contract.rb', application_contract_template
+
+          puts "\nDone! Next steps:\n  cd #{name}\n  bundle install\n  bundle exec falcon host falcon.rb"
+        end
+
+        private
+
+        def create_dir(path)
+          FileUtils.mkdir_p(path)
+          puts "  create  #{path}/"
+        end
+
+        def write(root, relative_path, content)
+          File.write(File.join(root, relative_path), content)
+          puts "  create  #{relative_path}"
+        end
+
+        def gemfile
+          <<~RUBY
+            source 'https://rubygems.org'
+
+            gem 'rivulet-rb'
+            gem 'falcon'
+          RUBY
+        end
+
+        def config_ru
+          <<~RUBY
+            require 'rivulet'
+
+            run Rivulet.app.startup
+          RUBY
+        end
+
+        def application_config(name)
+          <<~RUBY
+            Rivulet.configure do |config|
+              # config.database.dsn = ENV.fetch('DATABASE_URL', 'sqlite://db/#{name}.sqlite3')
+
+              # config.sendfile.enabled   = true
+              # config.sendfile.variation = 'x-accel-redirect'
+              # config.sendfile.mappings   = [['/var/www/', '/files/']]
+
+              config.logger.name  = :#{name}
+              config.logger.level = :info
+            end
+          RUBY
+        end
+
+        def falcon_config
+          <<~RUBY
+            require 'falcon/environment/rack'
+            require 'falcon/environment/server'
+
+            service "app" do
+              include Falcon::Environment::Server
+              include Falcon::Environment::Rackup
+            end
+          RUBY
+        end
+
+        def routes_config
+          <<~RUBY
+            # get :posts, to: 'posts#index'
+
+            Rivulet.routes.draw do
+            end
+          RUBY
+        end
+
+        def handlers_container
+          <<~RUBY
+            module Handlers
+              extend Dry::Core::Container::Mixin
+            end
+          RUBY
+        end
+
+        def handlers_shared_container
+          <<~RUBY
+            module Handlers
+              module Shared
+                class Container
+                  extend Dry::Core::Container::Mixin
+                  import Namespace
+                end
+              end
+            end
+          RUBY
+        end
+
+        def handlers_shared_namespace
+          <<~RUBY
+            module Handlers
+              module Shared
+                Namespace = Dry::Core::Container::Namespace.new('shared') do
+                  namespace('steps') do
+                  end
+
+                  namespace('utils') do
+                  end
+                end
+              end
+            end
+          RUBY
+        end
+
+        def services_container
+          <<~RUBY
+            module Services
+              extend Dry::Core::Container::Mixin
+            end
+          RUBY
+        end
+
+        def services_shared_container
+          <<~RUBY
+            module Services
+              module Shared
+                class Container
+                  extend Dry::Core::Container::Mixin
+                  import Namespace
+                end
+              end
+            end
+          RUBY
+        end
+
+        def services_shared_namespace
+          <<~RUBY
+            module Services
+              module Shared
+                Namespace = Dry::Core::Container::Namespace.new('shared') do
+                  namespace('steps') do
+                  end
+
+                  namespace('utils') do
+                  end
+                end
+              end
+            end
+          RUBY
+        end
+
+        def application_contract_template
+          <<~RUBY
+            class ApplicationContract < Dry::Validation::Contract
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/rivulet/cli/routes.rb

@@ -0,0 +1,15 @@
+require 'rivulet'
+
+module Rivulet
+  module CLI
+    module Commands
+      class Routes < Dry::CLI::Command
+        desc 'Show routes'
+
+        def call(**)
+          Rivulet.app.print_routes
+        end
+      end
+    end
+  end
+end

data/lib/rivulet/cli.rb

@@ -0,0 +1,43 @@
+require 'dry/cli'
+require_relative 'cli/new'
+require_relative 'cli/console'
+require_relative 'cli/routes'
+require_relative 'cli/db/migrate'
+require_relative 'cli/generate/operation'
+require_relative 'cli/generate/handler'
+require_relative 'cli/generate/handler/operation'
+require_relative 'cli/generate/handler/step'
+require_relative 'cli/generate/migration'
+require_relative 'cli/generate/resource'
+require_relative 'cli/generate/service'
+require_relative 'cli/generate/service/operation'
+require_relative 'cli/generate/service/step'
+require_relative 'cli/generate/service/projection'
+
+module Rivulet
+  module CLI
+    module Commands
+      extend Dry::CLI::Registry
+
+      register 'new', Commands::New
+      register 'console', Commands::Console, aliases: ['c']
+      register 'routes', Commands::Routes
+
+      register 'generate', aliases: ['g'] do |prefix|
+        prefix.register 'resource',           Commands::Generate::Resource
+        prefix.register 'service',            Commands::Generate::Service
+        prefix.register 'service operation',  Commands::Generate::Service::Operation
+        prefix.register 'service step',       Commands::Generate::Service::Step
+        prefix.register 'service projection', Commands::Generate::Service::Projection
+        prefix.register 'handler',            Commands::Generate::Handler
+        prefix.register 'handler operation',  Commands::Generate::Handler::Operation
+        prefix.register 'handler step',       Commands::Generate::Handler::Step
+        prefix.register 'migration',          Commands::Generate::Migration
+      end
+
+      register 'db' do |prefix|
+        prefix.register 'migrate', Commands::DB::Migrate
+      end
+    end
+  end
+end