rivulet-rb 0.1.0

data/lib/rivulet/steps/print_routes.rb

@@ -0,0 +1,123 @@
+require "io/console"
+
+module Rivulet
+  module Steps
+    class PrintRoutes < Rivulet::Step
+      HEADERS = ['HTTP Verb', 'Path', 'Handler#action']
+      GAP = 2
+
+      def call(input)
+        routes = input[:resource].routes
+
+        widths = calculate_widths(routes)
+
+        print_row(HEADERS, widths)
+        puts "" # Spacer after header
+
+        routes.each do |route|
+          print_route(route, widths)
+        end
+
+        Success(input)
+      end
+
+      private
+
+      def terminal_width
+        IO.console.winsize[1]
+      rescue
+        80
+      end
+
+      def calculate_widths(routes)
+        cols = HEADERS.size
+        route_methods = [:http_method, :path, :callable]
+
+        widths = Array.new(cols, 0)
+
+        cols.times do |i|
+          widths[i] = [
+            HEADERS[i].length,
+            *routes.map { |r| r.send(route_methods[i]).to_s.length }
+          ].max
+        end
+
+        total_width_needed = widths.sum + GAP * (cols - 1)
+
+        return widths if total_width_needed <= terminal_width
+
+        # If too wide, shrink the last column to fit, prioritizing wrapping there.
+        fixed_width = widths[0..-2].sum + GAP * (cols - 2)
+        available_for_last = terminal_width - fixed_width - GAP
+
+        widths[-1] = [available_for_last, 20].max
+
+        # Final fallback to ensure total doesn't exceed terminal width
+        while (widths.sum + GAP * (cols - 1)) > terminal_width && widths[-1] > 5
+          widths[-
+1] -= 1
+        end
+
+        widths
+      end
+
+      def print_route(route, widths)
+        handler_display = route.handler_name || route.callable.inspect
+        row_data = [route.http_method, route.path, handler_display]
+        print_row(row_data, widths)
+      end
+
+      def print_row(cells, widths)
+        wrapped_cells = cells.each_with_index.map do |cell, i|
+          wrap(cell.to_s, widths[i])
+        end
+
+        num_lines = wrapped_cells.map(&:size).max
+
+        num_lines.times do |line_idx|
+          line_parts = wrapped_cells.each_with_index.map do |lines, col_idx|
+            text = lines[line_idx] || ""
+            text.ljust(widths[col_idx])
+          end
+
+          puts line_parts.join(" " * GAP)
+        end
+      end
+
+      def wrap(text, width)
+        return [] if text.empty?
+
+        tokens = text.split(/(\s+)/)
+        lines = []
+        current_line = ""
+
+        tokens.each do |token|
+          if (current_line + token).length <= width
+            current_line += token
+          else
+            if token.strip.empty?
+              lines << current_line.rstrip
+              current_line = ""
+            elsif token.length > width
+              parts = token.scan(/.{1,#{width}}/)
+              parts.each_with_index do |part, idx|
+                if idx == parts.size - 1
+                  current_line += part
+                else
+                  lines << (current_line + part).rstrip
+                  current_line = ""
+                end
+              end
+            else
+              lines << current_line.rstrip
+              current_line = token
+            end
+          end
+        end
+
+        lines << current_line.rstrip unless current_line.empty?
+        lines.reject(&:empty?)
+      end
+    end
+  end
+end

data/lib/rivulet/steps/run_console.rb

@@ -0,0 +1,26 @@
+require 'irb'
+require 'irb/completion'
+
+module Rivulet
+  module Steps
+    class RunConsole < Rivulet::Step
+      def call(input)
+        app = input[:resource]
+
+        IRB.setup(nil)
+
+        IRB.conf[:USE_AUTOCOMPLETE] = false
+        IRB.conf[:AP_NAME] = 'rivulet'
+
+        # workspace = IRB::WorkSpace.new(binding)
+        # irb = IRB::Irb.new(workspace)
+
+        # IRB.conf[:MAIN_CONTEXT] = irb.context
+
+        IRB::Irb.new.run(IRB.conf)
+
+        Success(input)
+      end
+    end
+  end
+end

data/lib/rivulet/steps/run_migrations.rb

@@ -0,0 +1,50 @@
+module Rivulet
+  module Steps
+    class RunMigrations < Rivulet::Step
+      TABLE = :schema_migrations
+
+      def call(input)
+        db = input[:resource].db
+        return Failure("Database not configured") unless db
+
+        ensure_table(db)
+        migrations = pending(db)
+
+        if migrations.empty?
+          puts "  up to date"
+        else
+          migrations.each do |path|
+            version = File.basename(path, '.sql')
+            db.transaction do
+              db.run(File.read(path))
+              db[TABLE].insert(version: version)
+            end
+            puts "  applied  #{File.basename(path)}"
+          end
+        end
+
+        Success(input)
+      end
+
+      private
+
+      def ensure_table(db)
+        db.create_table?(TABLE) do
+          String :version, null: false
+          primary_key [:version]
+        end
+      end
+
+      def pending(db)
+        applied = db[TABLE].select_map(:version).to_set
+        all_files.reject { |f| applied.include?(File.basename(f, '.sql')) }
+      end
+
+      def all_files
+        dir = File.expand_path('db/migrations')
+        return [] unless Dir.exist?(dir)
+        Dir[File.join(dir, '*.sql')].sort
+      end
+    end
+  end
+end

data/lib/rivulet/steps/validate_response.rb

@@ -0,0 +1,42 @@
+module Rivulet
+  module Steps
+    class ValidateResponse < Rivulet::Step
+      NO_BODY_STATUSES = [204, 304].freeze
+      FORMAT_VALUES = %i[json text file stream as_is].freeze
+
+      def call(input)
+        input => { response:, route: }
+
+        unless response.is_a? Rivulet::Response
+          return Failure[:wrong_response_type, "Invalid response type for #{route.path}"]
+        end
+
+        if NO_BODY_STATUSES.include?(response.status) && !response.body.nil?
+          return Failure[:conflicting_response, "Status #{response.status} has body #{response.body}"]
+        end
+
+        unless FORMAT_VALUES.include?(response.format)
+          return Failure[:wrong_response_format, "Unsupported response format #{response.format.inspect}"]
+        end
+
+        if response.format == :stream && !io_like?(response.body)
+          return Failure[:wrong_response_type, 'Response body is not supported for stream format']
+        end
+
+        if response.format == :file
+          body = response.body
+          return Failure[:wrong_response_type, "File body requires :path key"] if body.is_a?(Hash) && !body.key?(:path)
+          return Failure[:wrong_response_type, "Response body is not supported for file format"] unless body.is_a?(String) || body.is_a?(Hash)
+        end
+
+        Success(input)
+      end
+
+      private
+
+      def io_like?(obj)
+        %i[gets each read rewind].all? { obj.respond_to?(_1) }
+      end
+    end
+  end
+end

data/lib/rivulet/telemetry/node.rb

@@ -0,0 +1,8 @@
+module Rivulet
+  class Telemetry
+    Node = Struct.new(
+      :name, :started_at, :ended_at, :duration_ms,
+      :self_ms, :children, keyword_init: true
+    )
+  end
+end

data/lib/rivulet/telemetry/sequel_extension.rb

@@ -0,0 +1,19 @@
+module Rivulet
+  class Telemetry
+    module SequelExtension
+      def log_connection_yield(*args, &block)
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        super
+      ensure
+        elapsed = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000
+        Fiber[:rivulet_telemetry]&.record_db(elapsed)
+      end
+    end
+  end
+end
+
+if defined?(Sequel)
+  Sequel::Database.register_extension(:rivulet_telemetry) do |db|
+    db.extend(Rivulet::Telemetry::SequelExtension)
+  end
+end

data/lib/rivulet/telemetry/timing_wrapper.rb

@@ -0,0 +1,12 @@
+module Rivulet
+  class Telemetry
+    module TimingWrapper
+      def call(...)
+        Fiber[:rivulet_telemetry]&.start_recording(self)
+        super
+      ensure
+        Fiber[:rivulet_telemetry]&.stop_recording(self)
+      end
+    end
+  end
+end

data/lib/rivulet/telemetry.rb

@@ -0,0 +1,62 @@
+module Rivulet
+  class Telemetry
+    attr_reader :db_ms
+
+    def initialize
+      @started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @root       = nil
+      @stack      = []
+      @db_ms      = 0.0
+    end
+
+    def start_recording(activity)
+      node = Rivulet::Telemetry::Node.new(
+        name: activity.class.name,
+        started_at: Process.clock_gettime(Process::CLOCK_MONOTONIC),
+        children: []
+      )
+
+      if @stack.empty?
+        @root = node
+      else
+        @stack.last[:children] << node
+      end
+
+      @stack << node
+    end
+
+    def stop_recording(activity)
+      node = @stack.pop
+      node.ended_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      node.duration_ms =
+        ((node.ended_at - node.started_at) * 1000.0).round(3)
+      node.self_ms =
+        (node.duration_ms - node.children.sum(&:duration_ms)).round(3)
+    end
+
+    def record_db(ms)
+      @db_ms = (@db_ms + ms).round(3)
+    end
+
+    def total_ms
+      ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - @started_at) * 1000).round(3)
+    end
+
+    def flow
+      @root
+    end
+
+    def print_flow(node = @root, offset = 0)
+      entry = " " * 2 * offset
+      entry += "#{node.name} (#{node.self_ms})"
+      entry += " =>" if node.children.any?
+      entry += "\n"
+
+      node.children.each do |cnode|
+        entry += print_flow(cnode, offset + 1)
+      end
+
+      entry
+    end
+  end
+end

data/lib/rivulet/version.rb

@@ -0,0 +1,3 @@
+module Rivulet
+  VERSION = '0.1.0'
+end

data/lib/rivulet.rb

@@ -0,0 +1,66 @@
+require 'forwardable'
+require 'dry/monads'
+require 'dry/operation'
+require 'dry/configurable'
+require 'dry/auto_inject'
+require 'dry/core/container'
+require 'dry/logger'
+require 'dry/validation'
+require 'dry/transformer'
+require 'oj'
+require 'protocol/http'
+require 'protocol/http/body/file'
+require 'protocol/http/body/stream'
+require 'rack'
+require 'rack/utils'
+require 'sequel'
+
+require_relative 'rivulet/version'
+require_relative 'rivulet/telemetry'
+require_relative 'rivulet/telemetry/node'
+require_relative 'rivulet/telemetry/sequel_extension'
+require_relative 'rivulet/telemetry/timing_wrapper'
+require_relative 'rivulet/step'
+require_relative 'rivulet/container'
+require_relative 'rivulet/operation'
+require_relative 'rivulet/request'
+require_relative 'rivulet/response'
+require_relative 'rivulet/projection'
+require_relative 'rivulet/routing/route'
+require_relative 'rivulet/routing/mapper'
+require_relative 'rivulet/steps/build_config'
+require_relative 'rivulet/steps/build_context'
+require_relative 'rivulet/steps/validate_response'
+require_relative 'rivulet/steps/compile_response'
+require_relative 'rivulet/steps/dispatch'
+require_relative 'rivulet/steps/load_app'
+require_relative 'rivulet/steps/load_db'
+require_relative 'rivulet/steps/load_routes'
+require_relative 'rivulet/steps/load_settings'
+require_relative 'rivulet/steps/print_routes'
+require_relative 'rivulet/steps/run_migrations'
+require_relative 'rivulet/steps/run_console'
+require_relative 'rivulet/operations/startup'
+require_relative 'rivulet/operations/dispatch_request'
+require_relative 'rivulet/operations/migrate'
+require_relative 'rivulet/operations/print_routes'
+require_relative 'rivulet/operations/run_console'
+require_relative 'rivulet/application'
+
+module Rivulet
+  extend SingleForwardable
+
+  def_delegators :app, :config, :configure, :routes, :logger
+
+  def self.app
+    return @app if @app
+
+    @app = Application.new
+    @app
+  end
+
+  def self.plugin(as: 'rivulet')
+    Dry::Core::Container::Namespace.new(as) do
+    end
+  end
+end