rivulet-rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5ae318924632d21dfc60983838454a230011b5c6a762446c52b927870074980c
+  data.tar.gz: eb65be1dcabda72c0ce3d590e6952d8929f1b945f23344de7fcc2403188a94eb
+SHA512:
+  metadata.gz: 0c6433c7c4814dd1d763d1d16d01ce903a9b84b308451766e1f6f64625c8195235526faf95c78fa43a2f1bfe9d4f4c9d9dfdbf69454c6ca0a92d6ec3f8a3c05a
+  data.tar.gz: fdb3fe00dd3280bce1844cd9ef71ae24c3c30f398d4aaea45cfe755442c6c2a4413c7d183f04938c5770f1b9c5910a61ff549377b304b63851c66c40f12e6b11

data/bin/rivulet

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative '../lib/rivulet/cli'
+
+Dry::CLI.new(Rivulet::CLI::Commands).call

data/lib/rivulet/application.rb

@@ -0,0 +1,90 @@
+module Rivulet
+  class Application
+    include Dry::Configurable
+    include Dry::Monads[:result]
+    include Dry::AutoInject(Rivulet::Container)[
+      dispatch_request:       'operations.dispatch_request',
+      startup_operation:      'operations.startup',
+      migrate_operation:      'operations.migrate',
+      run_console_operation:  'operations.run_console',
+      print_routes_operation: 'operations.print_routes'
+    ]
+
+    attr_accessor :db
+
+    def call(env)
+      result = with_telemetry do
+        dispatch_request.(resource: self, env: env)
+      end
+
+      return result.success[:response] if result.success?
+
+      case result
+      in Failure[:route_not_found]
+        [404, { 'Content-Type' => 'text/plain' }, ['Not Found']]
+      in Failure[:wrong_response_type, message]
+        logger.error(message)
+        [500, {}, []]
+      in Failure[:conflicting_response, message]
+        logger.error(message)
+        [500, {}, []]
+      in Failure[:file_not_found, message]
+        logger.error(message)
+        [500, {}, []]
+      end
+    end
+
+    def routes
+      @routes ||= Routing::Mapper.new([])
+    end
+
+    def startup
+      result = startup_operation.(resource: self)
+      if result.failure?
+        warn "Startup failed: #{result.failure}"
+        exit 1
+      end
+      self
+    end
+
+    def migrate!
+      result = migrate_operation.(resource: self)
+      if result.failure?
+        warn "Migration failed: #{result.failure}"
+        exit 1
+      end
+    end
+
+    def run_console
+      result = run_console_operation.(resource: self)
+      if result.failure?
+        warn "Cannot start console: #{result.failure}"
+        exit 1
+      end
+    end
+
+    def print_routes
+      result = print_routes_operation.(resource: self)
+      if result.failure?
+        warn "Cannot print routes: #{result.failure}"
+        exit 1
+      end
+    end
+
+    private
+
+    def with_telemetry
+      t = Telemetry.new
+      Fiber[:rivulet_telemetry] = t
+
+      result = yield
+
+      logger.info(
+        "Completed total_ms=#{t.total_ms} db_ms=#{t.db_ms} flow:\n#{t.print_flow}"
+      )
+      result
+    ensure
+      Fiber[:rivulet_telemetry] = nil
+    end
+  end
+end

data/lib/rivulet/cli/console.rb

@@ -0,0 +1,15 @@
+require 'rivulet'
+
+module Rivulet
+  module CLI
+    module Commands
+      class Console < Dry::CLI::Command
+        desc 'Run console within rivulet environmet'
+
+        def call(**)
+          Rivulet.app.run_console
+        end
+      end
+    end
+  end
+end

data/lib/rivulet/cli/db/migrate.rb

@@ -0,0 +1,17 @@
+require 'rivulet'
+
+module Rivulet
+  module CLI
+    module Commands
+      module DB
+        class Migrate < Dry::CLI::Command
+          desc "Run pending database migrations"
+
+          def call(**)
+            Rivulet.app.migrate!
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+require 'fileutils'
+
+module Rivulet
+  module CLI
+    module Commands
+      module Generate
+        class Handler
+          class Operation < Dry::CLI::Command
+            desc "Generate an operation"
+            argument :name, required: true, desc: "Operation name in handler.operation format (e.g. users.create)"
+
+            def call(name:, **)
+              handler_name, operation_name = name.split('.')
+              handler_dir      = underscore(handler_name)
+              operation_dir    = underscore(operation_name)
+              handler_module   = camelize(handler_dir)
+              operation_module = camelize(operation_dir)
+              base             = "app/handlers/#{handler_dir}"
+
+              write "#{base}/operations/#{operation_dir}.rb", operation_template(handler_module, operation_module)
+              register_operation(base, handler_dir, handler_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 write(path, content)
+              File.write(path, content)
+              puts "  create  #{path}"
+            end
+
+            def operation_template(handler_module, operation_module)
+              <<~RUBY
+                module Handlers
+                  module #{handler_module}
+                    module Operations
+                      class #{operation_module} < Rivulet::Operation
+                        def call(input = {})
+                        end
+                      end
+                    end
+                  end
+                end
+              RUBY
+            end
+
+            def register_operation(base, handler_dir, handler_module, operation_dir, operation_module)
+              container_file        = "#{base}/container.rb"
+              op_registration       = "        register('#{operation_dir}') { Handlers::#{handler_module}::Operations::#{operation_module}.new }\n"
+
+              if File.exist?(container_file)
+                content = File.read(container_file)
+                content.sub!(/(      namespace\('operations'\) do\n)/, "\\1#{op_registration}")
+                File.write(container_file, content)
+                puts "  update  #{container_file}"
+              else
+                write container_file, container_template(handler_module, operation_dir, operation_module)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+require 'fileutils'
+
+module Rivulet
+  module CLI
+    module Commands
+      module Generate
+        class Handler
+          class Step < Dry::CLI::Command
+            desc "Generate a step"
+            argument :name, required: true, desc: "Step name in handler.step format (e.g. users.create)"
+
+            def call(name:, **)
+              handler_name, step_name = name.split('.')
+              handler_dir    = underscore(handler_name)
+              step_dir       = underscore(step_name)
+              handler_module = camelize(handler_dir)
+              step_class     = camelize(step_dir)
+              base           = "app/handlers/#{handler_dir}"
+
+              write "#{base}/steps/#{step_dir}.rb", step_template(handler_module, step_class)
+              register_step(base, handler_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(handler_module, step_class)
+              <<~RUBY
+                module Handlers
+                  module #{handler_module}
+                    module Steps
+                      class #{step_class} < Rivulet::Step
+                        def call(input)
+                        end
+                      end
+                    end
+                  end
+                end
+              RUBY
+            end
+
+            def register_step(base, handler_module, step_dir, step_module)
+              container_file       = "#{base}/container.rb"
+              step_registration      = "        register('#{step_dir}') { Handlers::#{handler_module}::Steps::#{step_module}.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(handler_module, step_dir, step_module)
+              end
+            end
+
+            def container_template(handler_module, step_name, step_class)
+              <<~RUBY
+                module Handlers
+                  module #{handler_module}
+                    class Container
+                      extend Dry::Core::Container::Mixin
+
+                      namespace('steps') do
+                        register('#{step_name}') { Handlers::#{service_module}::Steps::#{step_class}.new }
+                      end
+                    end
+                  end
+                end
+              RUBY
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+require 'fileutils'
+
+module Rivulet
+  module CLI
+    module Commands
+      module Generate
+        class Handler < Dry::CLI::Command
+          desc "Generate a handler"
+          argument :name, required: true, desc: "Handler name (e.g. Users or users)"
+
+          option :create, type: :boolean, aliases: ['-c'], desc: 'Add "create" operation'
+          option :read,   type: :boolean, aliases: ['-r'], desc: 'Add "show" 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 "index" operation'
+
+          SUBDIRS = %w[operations steps].freeze
+
+          def call(name:, **options)
+            dir_name    = underscore(name)
+            module_name = camelize(dir_name)
+            base        = "app/handlers/#{dir_name}"
+
+            SUBDIRS.each { |d| create_dir "#{base}/#{d}" }
+            write "#{base}/handler.rb", handler_template(module_name)
+            create_container(base, module_name) unless File.exist?("#{base}/container.rb")
+            register_handler(dir_name, module_name)
+
+            if options[:create]
+              Operation.new.call(name: "#{name}.create")
+            end
+
+            if options[:read]
+              Operation.new.call(name: "#{name}.show")
+            end
+
+            if options[:update]
+              Operation.new.call(name: "#{name}.update")
+            end
+
+            if options[:delete]
+              Operation.new.call(name: "#{name}.delete")
+            end
+
+            if options[:list]
+              Operation.new.call(name: "#{name}.index")
+            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_container(base, module_name)
+            write "#{base}/container.rb", container_template(module_name)
+          end
+
+          def create_dir(path)
+            FileUtils.mkdir_p(path)
+            puts "  create  #{path}/"
+          end
+
+          def write(path, content)
+            File.write(path, content)
+            puts "  create  #{path}"
+          end
+
+          def handler_template(module_name)
+            <<~RUBY
+              module Handlers
+                module #{module_name}
+                  class Handler
+                    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 Handlers
+                module #{module_name}
+                  class Container
+                    extend Dry::Core::Container::Mixin
+                    import Handlers::Shared::Namespace
+
+                    namespace('operations') do
+                    end
+
+                    namespace('steps') do
+                    end
+                  end
+                end
+              end
+            RUBY
+          end
+
+          def register_handler(dir_name, module_name)
+            handlers_file = 'app/handlers.rb'
+            return unless File.exist?(handlers_file)
+
+            content      = File.read(handlers_file)
+            registration = "  register('#{dir_name}') { Handlers::#{module_name}::Handler.new }\n"
+
+            updated = content.sub(/^end\s*\z/, "#{registration}end\n")
+            File.write(handlers_file, updated)
+            puts "  update  #{handlers_file}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'fileutils'
+
+module Rivulet
+  module CLI
+    module Commands
+      module Generate
+        class Migration < Dry::CLI::Command
+          desc "Generate a migration"
+          argument :name, required: true, desc: "Migration name (e.g. create_users)"
+
+          def call(name:, **)
+            FileUtils.mkdir_p('db/migrations')
+            filename = "#{Time.now.strftime('%Y%m%d%H%M%S')}_#{underscore(name)}.sql"
+            path     = File.join('db/migrations', filename)
+            File.write(path, "")
+            puts "  create  #{path}"
+          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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+require 'fileutils'
+
+module Rivulet
+  module CLI
+    module Commands
+      module Generate
+        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}"
+
+            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 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}
+                      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

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

@@ -0,0 +1,25 @@
+require 'fileutils'
+
+module Rivulet
+  module CLI
+    module Commands
+      module Generate
+        class Resource < Dry::CLI::Command
+          desc "Generate a resource (handler + service)"
+          argument :name, required: true, desc: "Resource name (e.g. Users or users)"
+
+          option :create, type: :boolean, aliases: ['-c'], desc: 'Add operations to create resource'
+          option :read,   type: :boolean, aliases: ['-r'], desc: 'Add operations to read resource'
+          option :update, type: :boolean, aliases: ['-u'], desc: 'Add operations to update resource'
+          option :delete, type: :boolean, aliases: ['-d'], desc: 'Add operations to delete resource'
+          option :list,   type: :boolean, aliases: ['-l'], desc: 'Add operations to list resource'
+
+          def call(name:, **options)
+            Handler.new.call(name: name, **options)
+            Service.new.call(name: name, **options)
+          end
+        end
+      end
+    end
+  end
+end