rivulet-rb 0.1.0

data/lib/rivulet/container.rb

@@ -0,0 +1,28 @@
+module Rivulet
+  class Container
+    extend Dry::Core::Container::Mixin
+
+    namespace('operations') do
+      register('startup')          { Rivulet::Operations::Startup.new }
+      register('dispatch_request') { Rivulet::Operations::DispatchRequest.new }
+      register('migrate')          { Rivulet::Operations::Migrate.new }
+      register('run_console')      { Rivulet::Operations::RunConsole.new }
+      register('print_routes')     { Rivulet::Operations::PrintRoutes.new }
+    end
+
+    namespace('steps') do
+      register('build_config')      { Rivulet::Steps::BuildConfig.new }
+      register('build_context')     { Rivulet::Steps::BuildContext.new }
+      register('validate_response') { Rivulet::Steps::ValidateResponse.new }
+      register('compile_response')  { Rivulet::Steps::CompileResponse.new }
+      register('dispatch')          { Rivulet::Steps::Dispatch.new }
+      register('load_app')          { Rivulet::Steps::LoadApp.new }
+      register('load_settings')     { Rivulet::Steps::LoadSettings.new }
+      register('load_db')           { Rivulet::Steps::LoadDb.new }
+      register('load_routes')       { Rivulet::Steps::LoadRoutes.new }
+      register('run_migrations')    { Rivulet::Steps::RunMigrations.new }
+      register('run_console')       { Rivulet::Steps::RunConsole.new }
+      register('print_routes')      { Rivulet::Steps::PrintRoutes.new }
+    end
+  end
+end

data/lib/rivulet/operation.rb

@@ -0,0 +1,21 @@
+module Rivulet
+  class Operation < Dry::Operation
+    def self.container_class_path
+      self
+        .name
+        .split('::')
+        .then { |path| path[0...path.index('Operations')] }
+        .push('Container')
+        .inject(Object) { |mod, name| mod.const_get(name) }
+    end
+
+    def self.inherited(subclass)
+      super
+
+      subclass.prepend(Rivulet::Telemetry::TimingWrapper)
+      subclass.const_set(
+        :Import, Dry::AutoInject(subclass.container_class_path)
+      )
+    end
+  end
+end

data/lib/rivulet/operations/dispatch_request.rb

@@ -0,0 +1,21 @@
+module Rivulet
+  module Operations
+    class DispatchRequest < Rivulet::Operation
+      include Import[
+        build_context:      'steps.build_context',
+        dispatch:           'steps.dispatch',
+        validate_response:  'steps.validate_response',
+        compile_response:   'steps.compile_response'
+      ]
+
+      def call(input = {})
+        result = step build_context.(input)
+        result = step dispatch.(result)
+        result = step validate_response.(result)
+        result = step compile_response.(result)
+
+        result
+      end
+    end
+  end
+end

data/lib/rivulet/operations/migrate.rb

@@ -0,0 +1,23 @@
+module Rivulet
+  module Operations
+    class Migrate < Rivulet::Operation
+      include Import[
+        build_config:   'steps.build_config',
+        load_settings:  'steps.load_settings',
+        load_app:       'steps.load_app',
+        load_db:        'steps.load_db',
+        run_migrations: 'steps.run_migrations'
+      ]
+
+      def call(input = {})
+        result = step build_config.(input)
+        result = step load_settings.(result)
+        result = step load_db.(result)
+        result = step load_app.(result)
+        result = step run_migrations.(result)
+
+        result
+      end
+    end
+  end
+end

data/lib/rivulet/operations/print_routes.rb

@@ -0,0 +1,17 @@
+module Rivulet
+  module Operations
+    class PrintRoutes < Rivulet::Operation
+      include Import[
+        load_routes: 'steps.load_routes',
+        print_routes: 'steps.print_routes'
+      ]
+
+      def call(input = {})
+        result = step load_routes.(input)
+        result = step print_routes.(result)
+
+        result
+      end
+    end
+  end
+end

data/lib/rivulet/operations/run_console.rb

@@ -0,0 +1,25 @@
+module Rivulet
+  module Operations
+    class RunConsole < Rivulet::Operation
+      include Import[
+        build_config:  'steps.build_config',
+        load_settings: 'steps.load_settings',
+        load_app:      'steps.load_app',
+        load_db:       'steps.load_db',
+        load_routes:   'steps.load_routes',
+        run_console:   'steps.run_console'
+      ]
+
+      def call(input = {})
+        result = step build_config.(input)
+        result = step load_settings.(result)
+        result = step load_db.(result)
+        result = step load_app.(result)
+        result = step load_routes.(result)
+        result = step run_console.(result)
+
+        result
+      end
+    end
+  end
+end

data/lib/rivulet/operations/startup.rb

@@ -0,0 +1,23 @@
+module Rivulet
+  module Operations
+    class Startup < Rivulet::Operation
+      include Import[
+        build_config:  'steps.build_config',
+        load_settings: 'steps.load_settings',
+        load_app:      'steps.load_app',
+        load_db:       'steps.load_db',
+        load_routes:   'steps.load_routes'
+      ]
+
+      def call(input = {})
+        result = step build_config.(input)
+        result = step load_settings.(result)
+        result = step load_db.(result)
+        result = step load_app.(result)
+        result = step load_routes.(result)
+
+        result
+      end
+    end
+  end
+end

data/lib/rivulet/projection.rb

@@ -0,0 +1,6 @@
+module Rivulet
+  class Projection < Dry::Transformer::Pipe
+    import Dry::Transformer::ArrayTransformations
+    import Dry::Transformer::HashTransformations
+  end
+end

data/lib/rivulet/request.rb

@@ -0,0 +1,18 @@
+module Rivulet
+  class Request
+    attr_reader :http_method, :path, :content_type, :body, :session, :env
+
+    def initialize(env)
+      @http_method  = env['REQUEST_METHOD'].downcase.to_sym
+      @path         = env['PATH_INFO']
+      @content_type = env['CONTENT_TYPE']
+      @body         = env['rack.input']
+      @session      = env['rack.session']
+      @env          = env
+    end
+
+    def cookies
+      Rack::Utils.parse_cookies(env)
+    end
+  end
+end

data/lib/rivulet/response.rb

@@ -0,0 +1,12 @@
+module Rivulet
+  class Response
+    attr_accessor :status, :headers, :body, :format
+
+    def initialize(status: 200, headers: {}, body: [], format: :json)
+      @status = status
+      @headers = headers
+      @body = body
+      @format = format
+    end
+  end
+end

data/lib/rivulet/routing/mapper.rb

@@ -0,0 +1,78 @@
+module Rivulet
+  module Routing
+    class Mapper
+      include Enumerable
+
+      def each(&block)
+        @routes.each(&block)
+      end
+
+      def initialize(routes, prefix: '', scopes: [])
+        @routes = routes
+        @prefix = prefix
+        @scopes = scopes
+      end
+
+      %i[get post put patch delete].each do |method|
+        define_method(method) do |path, to:|
+          handler_name = case to
+                         when String then to
+                         when Hash then "#{to[:to]}#{'#' + to[:action] if to[:action]}"
+                         else nil
+                         end
+
+          route_path = join(@prefix, path.to_s)
+          path_regex, param_names = compile_path(route_path)
+
+          @routes << Route.new(
+            http_method: method,
+            path:        route_path,
+            callable:    build_callable(to),
+            scopes:      @scopes,
+            handler_name: handler_name,
+            path_regex:   path_regex,
+            param_names:  param_names
+          )
+        end
+      end
+
+      def draw(&block)
+        instance_eval(&block)
+      end
+
+      def scope(name, &block)
+        Mapper.new(
+          @routes,
+          prefix: join(@prefix, name.to_s),
+          scopes: @scopes + [name]
+        ).instance_eval(&block)
+      end
+
+      def build_callable(to)
+        case to
+        when String
+          handler, action = to.split('#')
+        when Hash
+          handler, action = to.values_at(:to, :action)
+        else
+          raise 'Cannot parse route handler'
+        end
+
+        ->(input) { ::Handlers[handler].send(action, input) }
+      end
+
+      private
+
+      def join(*parts)
+        '/' + parts.flat_map { |p| p.to_s.split('/') }.reject(&:empty?).join('/')
+      end
+
+      def compile_path(path)
+        param_names = path.scan(/:([^\/]+)/).flatten.map(&:to_sym)
+        regex = /\A#{Regexp.escape(path).gsub(/:[^\/]+/, '([^/]+)')}\z/
+
+        [regex, param_names]
+      end
+    end
+  end
+end

data/lib/rivulet/routing/route.rb

@@ -0,0 +1,14 @@
+module Rivulet
+  module Routing
+    Route = Struct.new(
+      :http_method,
+      :path,
+      :callable,
+      :scopes,
+      :handler_name,
+      :path_regex,
+      :param_names,
+      keyword_init: true
+    )
+  end
+end

data/lib/rivulet/step.rb

@@ -0,0 +1,22 @@
+module Rivulet
+  class Step
+    include Dry::Monads[:result]
+
+    def self.container_class_path
+      self
+        .name
+        .split('::')
+        .then { |path| path[0...path.index('Steps')] }
+        .push('Container')
+        .inject(Object) { |mod, name| mod.const_get(name) }
+    end
+
+    def self.inherited(subclass)
+      super
+      subclass.prepend(Rivulet::Telemetry::TimingWrapper)
+      subclass.const_set(
+        :Import, Dry::AutoInject(subclass.container_class_path)
+      )
+    end
+  end
+end

data/lib/rivulet/steps/build_config.rb

@@ -0,0 +1,26 @@
+module Rivulet
+  module Steps
+    class BuildConfig < Rivulet::Step
+      def call(input)
+        Rivulet::Application.setting :database do
+          setting :dsn
+          setting :pool
+        end
+
+        Rivulet::Application.setting :logger, reader: true do
+          setting :engine
+          setting :name
+          setting :level
+        end
+
+        Rivulet::Application.setting :sendfile do
+          setting :enabled, default: false
+          setting :variation, default: 'x-accel-redirect'
+          setting :mappings, default: []
+        end
+
+        Success(input)
+      end
+    end
+  end
+end

data/lib/rivulet/steps/build_context.rb

@@ -0,0 +1,76 @@
+module Rivulet
+  module Steps
+    class BuildContext < Rivulet::Step
+      def call(input)
+        input => { env:, resource: }
+
+        request = Rivulet::Request.new(env)
+        routes = resource.routes
+
+        route, path_match = find_route(routes, request)
+        return Failure[:route_not_found] unless route
+
+        input.merge!(
+          route: route,
+          params: build_params(route, request, path_match),
+          context: {
+            headers: extract_headers(request),
+            cookies: request.cookies,
+            session: request.session
+          }
+        )
+
+        resource.logger.info(
+          "Request #{request.http_method.upcase} #{request.path} #{input[:params]}"
+        )
+
+        Success(input)
+      end
+
+      private
+
+      def build_params(route, request, path_match)
+        path_params = extract_params(route, path_match)
+        body_params = parse_body(request)
+        body_params.merge(path_params)
+      end
+
+      def parse_body(request)
+        return {} unless request.content_type&.include?('application/json')
+        raw = request.body.read
+        return {} if raw.nil? || raw.empty?
+        Oj.load(raw, symbolize_names: true)
+      rescue Oj::ParseError
+        {}
+      end
+
+      def find_route(routes, request)
+        request_method = request.http_method
+        path_info = request.path
+
+        routes.each do |route|
+          next unless route.http_method == request_method
+
+          path_match = route.path_regex.match(path_info)
+          return [route, path_match] if path_match
+        end
+
+        [nil, nil]
+      end
+
+      def extract_headers(request)
+        request.env.each_with_object({}) do |(key, value), headers|
+          if key.start_with?('HTTP_')
+            headers[key[5..].split('_').map(&:capitalize).join('-')] = value
+          elsif (key == 'CONTENT_TYPE' || key == 'CONTENT_LENGTH') && !value.to_s.empty?
+            headers[key.split('_').map(&:capitalize).join('-')] = value
+          end
+        end
+      end
+
+      def extract_params(route, path_match)
+        route.param_names.zip(path_match.captures).to_h
+      end
+    end
+  end
+end

data/lib/rivulet/steps/compile_response.rb

@@ -0,0 +1,113 @@
+module Rivulet
+  module Steps
+    class CompileResponse < Rivulet::Step
+      def call(input)
+        input => { resource:, response: }
+
+        status = response.status
+        format = response.format
+
+        body, headers =
+          case format
+          when :json
+            payload = Oj.dump(response.body, mode: :json)
+
+            [
+              Protocol::HTTP::Body::Buffered.wrap(payload),
+              {
+                'Content-Type'   => 'application/json',
+                'Content-Length' => payload.bytesize.to_s
+              }
+            ]
+          when :text
+            payload = response.body.to_s
+
+            [
+              Protocol::HTTP::Body::Buffered.wrap(payload),
+              {
+                'Content-Type'   => 'text/plain; charset=utf-8',
+                'Content-Length' => payload.bytesize.to_s
+              }
+            ]
+          when :file
+            result = build_file_body(response.body, resource)
+            return result if result in Failure
+            result
+          when :stream
+            [Protocol::HTTP::Body::Stream.new(response.body), {}]
+          when :as_is
+            [response.body, {}]
+          else
+            [[], {}]
+          end
+
+        headers.merge!(response.headers)
+
+        input[:response] = [status, headers, body]
+
+        Success(input)
+      end
+
+      private
+
+      def build_file_body(body, app)
+        path = body.is_a?(Hash) ? body[:path] : body
+
+        if app.config.sendfile.enabled
+          build_sendfile_body(body, path, app.config.sendfile)
+        else
+          build_streaming_file_body(body, path)
+        end
+      end
+
+      def build_streaming_file_body(body, path)
+        file_body =
+          begin
+            Protocol::HTTP::Body::File.open(path)
+          rescue Errno::ENOENT, Errno::EACCES
+            return Failure[:file_not_found, "Cannot read file: #{path}"]
+          end
+
+        [file_body, file_headers(body, file_body.length)]
+      end
+
+      def build_sendfile_body(body, path, sendfile_config)
+        uri     = map_sendfile_path(path, sendfile_config.mappings)
+        headers = file_headers(body, 0)
+        headers[sendfile_config.variation.downcase] = uri
+        [[], headers]
+      end
+
+      def map_sendfile_path(path, mappings)
+        return path if mappings.empty?
+
+        mappings.each do |internal, external|
+          mapped = path.sub(/\A#{Regexp.escape(internal)}/i, external)
+          return mapped unless mapped == path
+        end
+
+        path
+      end
+
+      def file_headers(body, length)
+        if body.is_a?(Hash)
+          path        = body[:path]
+          filename    = body.fetch(:filename) { File.basename(path) }
+          disposition = body.fetch(:disposition, 'inline')
+          mime_type   = body.fetch(:mime_type) { Rack::Mime.mime_type(File.extname(filename)) }
+
+          {
+            'Content-Type'        => mime_type,
+            'Content-Length'      => length.to_s,
+            'Content-Disposition' => "#{disposition}; filename=\"#{filename}\""
+          }
+        else
+          {
+            'Content-Type'   => Rack::Mime.mime_type(File.extname(body)),
+            'Content-Length' => length.to_s
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rivulet/steps/dispatch.rb

@@ -0,0 +1,17 @@
+module Rivulet
+  module Steps
+    class Dispatch < Rivulet::Step
+      def call(input)
+        input => { route:, params:, context: }
+
+        result = route.callable.call(params: params, context: context)
+
+        # We don't care if it's success or failure.
+        # The result will be a response anyway.
+        input[:response] = result.value_or(result.failure)
+
+        Success(input)
+      end
+    end
+  end
+end

data/lib/rivulet/steps/load_app.rb

@@ -0,0 +1,20 @@
+require 'zeitwerk'
+
+module Rivulet
+  module Steps
+    class LoadApp < Rivulet::Step
+      def call(input)
+        app_dir = File.expand_path('app')
+        return Success(input) unless Dir.exist?(app_dir)
+
+        loader = Zeitwerk::Loader.new
+        loader.push_dir(app_dir)
+        loader.push_dir("#{app_dir}/models")
+        loader.setup
+        loader.eager_load
+
+        Success(input)
+      end
+    end
+  end
+end

data/lib/rivulet/steps/load_db.rb

@@ -0,0 +1,24 @@
+require 'sequel'
+require_relative '../telemetry/sequel_extension'
+
+module Rivulet
+  module Steps
+    class LoadDb < Rivulet::Step
+      def call(input)
+        app = input[:resource]
+        db_config = app.config.database
+        return Failure("Rivulet.config.database.dsn is required") if db_config&.dsn.to_s.empty?
+
+        pool = db_config.pool&.to_h || {}
+        db   = Sequel.connect(db_config.dsn, **pool, logger: app.logger, sql_log_level: :debug)
+        db.extension(:rivulet_telemetry)
+        app.db = db
+
+        Sequel::Model.db = db
+        Sequel::Model.require_valid_table = false
+
+        Success(input)
+      end
+    end
+  end
+end

data/lib/rivulet/steps/load_routes.rb

@@ -0,0 +1,28 @@
+module Rivulet
+  module Steps
+    class LoadRoutes < Rivulet::Step
+      def call(input)
+        routes_file = File.expand_path('config/routes.rb')
+        return Failure("Routes file not found: #{routes_file}") unless File.exist?(routes_file)
+
+        load(routes_file)
+
+        duplicates = duplicate_routes(input[:resource].routes)
+        return Failure(duplicate_message(duplicates)) unless duplicates.empty?
+
+        Success(input)
+      end
+
+      private
+
+      def duplicate_routes(routes)
+        routes.group_by { |r| [r.http_method, r.path] }.select { |_, v| v.size > 1 }
+      end
+
+      def duplicate_message(duplicates)
+        list = duplicates.keys.map { |m, p| "#{m.to_s.upcase} #{p}" }.join(', ')
+        "Duplicate routes: #{list}"
+      end
+    end
+  end
+end

data/lib/rivulet/steps/load_settings.rb

@@ -0,0 +1,42 @@
+module Rivulet
+  module Steps
+    class LoadSettings < Rivulet::Step
+      def call(input)
+        app = input[:resource]
+        app_file = File.expand_path('config/application.rb')
+        return Failure(:settings_file_not_found) unless File.exist?(app_file)
+
+        load app_file
+
+        app.config.logger = app.config.logger.engine || default_logger(app)
+        app.config.finalize!
+
+        Success(input)
+      end
+
+      private
+
+      def default_logger(app)
+        Dry.Logger(app.config.logger.name, level: app.config.logger.level) do |setup|
+          setup.add_backend(
+            stream: $stdout,
+            log_if: :debug?,
+            template: '<gray>[%<severity>s]</gray> %<time>s %<message>s'
+          )
+
+          setup.add_backend(
+            stream: $stdout,
+            log_if: :info?,
+            template: '<blue>[%<severity>s]</blue> %<time>s %<message>s'
+          )
+
+          setup.add_backend(
+            stream: $stdout,
+            log_if: :error?,
+            template: '<red>[%<severity>s]</red> %<time>s %<message>s'
+          )
+        end
+      end
+    end
+  end
+end