itsi 0.2.2 → 0.2.4

data/gems/server/lib/itsi/server/config/options/nodelay.md

@@ -8,9 +8,9 @@ This option determines whether the Nagle's algorithm is disabled, allowing small
 
 ## Configuration
 ```ruby {filename=Itsi.rb}
-reuse_address true
+nodelay true
 ```
 
 ```ruby {filename=Itsi.rb}
-reuse_address false
+nodelay false
 ```

data/gems/server/lib/itsi/server/config/options/reuse_address.md

@@ -4,7 +4,7 @@ url: /options/reuse_address
 ---
 
 Configures whether the server should bind to the underlying socket using the `SO_REUSEADDR` option.
-This optiondetermines whether the server allows the reuse of local addresses during binding. This can be useful in scenarios where a socket needs to be quickly rebound without waiting for the operating system to release the address.
+This option determines whether the server allows the reuse of local addresses during binding. This can be useful in scenarios where a socket needs to be quickly rebound without waiting for the operating system to release the address.
 
 ## Configuration
 ```ruby {filename=Itsi.rb}

data/gems/server/lib/itsi/server/config/typed_struct.rb

@@ -1,5 +1,7 @@
-require 'date'
-require 'time'
+# frozen_string_literal: true
+
+require "date"
+require "time"
 
 module Itsi
   class Server
@@ -10,25 +12,19 @@ module Itsi
 
         def self.new(defaults = nil, &defaults_blk)
           defaults = TypedStruct.module_eval(&defaults_blk) if defaults_blk
-          unless defaults.is_a?(Hash)
-            return defaults
-          end
+          return defaults unless defaults.is_a?(Hash)
+
           defaults.transform_values! { _1.is_a?(Validation) ? _1.default(nil) : _1 }
           Struct.new(*defaults.keys, keyword_init: true) do
             define_method(:initialize) do |*input, validate: true, **raw_input|
+              raise "─ Invalid input to #{self}: #{input.last}" if input.last && !input.last.is_a?(Hash)
 
-              if input.last && !input.last.is_a?(Hash)
-                raise "─ Invalid input to #{self}: #{input.last}"
-              end
-              raw_input.transform_keys!{|k| k.to_s.downcase.to_sym }
-              raw_input.merge!(input.pop.transform_keys!{|k| k.to_s.downcase.to_sym}) if input.last.is_a?(Hash)
+              raw_input.transform_keys! { |k| k.to_s.downcase.to_sym }
+              raw_input.merge!(input.pop.transform_keys! { |k| k.to_s.downcase.to_sym }) if input.last.is_a?(Hash)
 
               excess_keys = raw_input.keys - defaults.keys
 
-              if excess_keys.any?
-                raise "─ Unsupported keys #{excess_keys}"
-
-              end
+              raise "─ Unsupported keys #{excess_keys}" if excess_keys.any?
 
               initial_values = defaults.each_with_object({}) do |(k, default_config), inputs|
                 value = raw_input.key?(k) ? raw_input[k] : default_config[VALUE].dup
@@ -106,9 +102,7 @@ module Itsi
 
           def &(other)
             tail = self
-            while tail.next
-              tail = tail.next
-            end
+            tail = tail.next while tail.next
             tail.next = other
             self
           end
@@ -148,10 +142,14 @@ module Itsi
                       elsif validation.eql?(::Date) then Date.parse(value.to_s)
                       elsif validation.eql?(Float) then Float(value)
                       elsif validation.eql?(Integer) then Integer(value)
-                      elsif validation.eql?(Proc) then
+                      elsif validation.eql?(Proc)
                         raise ArgumentError, "Invalid #{validation} value: #{value.inspect}" unless value.is_a?(Proc)
                       elsif validation.eql?(String) || validation.eql?(Symbol)
-                        raise ArgumentError, "Invalid #{validation} value: #{value.inspect}" unless value.is_a?(String) || value.is_a?(Symbol)
+                        unless value.is_a?(String) || value.is_a?(Symbol)
+                          raise ArgumentError,
+                                "Invalid #{validation} value: #{value.inspect}"
+                        end
+
                         if validation.eql?(String)
                           value.to_s
                         elsif validation.eql?(Symbol)
@@ -178,33 +176,32 @@ module Itsi
         {
           Bool: Validation.new(:Bool, [[true, false]]),
           Required: Validation.new(:Required, ->(value) { !value.nil? }),
-          Or: ->(*validations){
-            Validation.new(:Or, ->(v){
-
+          Or: lambda { |*validations|
+            Validation.new(:Or, lambda { |v|
               return true if v.nil?
+
               errs = []
               validations.each do |validation|
-                begin
-                  v = validation.validate!(v)
-                  return v
-                rescue StandardError => e
-                  errs << e.message
-                end
+                v = validation.validate!(v)
+                return v
+              rescue StandardError => e
+                errs << e.message
               end
               raise StandardError.new("─ Validation failed (None match:) \n  └#{errs.join("\n  └")}")
             })
           },
-          Range: ->(input_range) {
+          Range: lambda { |input_range|
             Validation.new(:Range, [input_range])
           },
           Length: lambda { |input_length|
             Validation.new(:Length, ->(value) { input_length === value.length })
           },
-          Hash: ->(key_type, value_type) {
-            Validation.new(:Hash, ->(v){
-              return true if v.nil?
-              raise StandardError.new("Expected hash got #{v.class}") unless v.is_a?(Hash)
-              v.map do |k, v|
+          Hash: lambda { |key_type, value_type|
+            Validation.new(:Hash, lambda { |hash|
+              return true if hash.nil?
+              raise StandardError.new("Expected hash got #{hash.class}") unless hash.is_a?(Hash)
+
+              hash.map do |k, v|
                 [
                   key_type.validate!(k),
                   value_type.validate!(v)
@@ -213,7 +210,7 @@ module Itsi
             })
           },
           Type: ->(input_type) { Validation.new(:Type, input_type) },
-          Enum: ->(allowed_values) { Validation.new(:Enum, [allowed_values.map{|v| v.kind_of?(Symbol) ? v.to_s : v}]) },
+          Enum: ->(allowed_values) { Validation.new(:Enum, [allowed_values.map { |v| v.is_a?(Symbol) ? v.to_s : v }]) },
           Array: lambda { |*value_validations|
             Validation.new(:Array, [::Array, lambda { |value|
               return true unless value

data/gems/server/lib/itsi/server/config.rb

@@ -41,15 +41,18 @@ module Itsi
           elsif args[:static]
             DSL.evaluate do
               location "/" do
-                rate_limit key: 'address', store_config: 'in_memory', requests: 2, seconds: 5
-                etag type: 'strong', algorithm: 'md5', min_body_size: 1024 * 1024
-                compress min_size: 1024 * 1024, level: 'fastest', algorithms: %w[zstd gzip br deflate], mime_types: %w[all], compress_streams: true
-                log_requests before: { level: "INFO", format: "[{request_id}] {method} {path_and_query} - {addr} " }, after: { level: "INFO", format: "[{request_id}] └─ {status} in {response_time}" }
+                rate_limit key: "address", store_config: "in_memory", requests: 2, seconds: 5
+                etag type: "strong", algorithm: "md5", min_body_size: 1024 * 1024
+                compress min_size: 1024 * 1024, level: "fastest", algorithms: %w[zstd gzip br deflate],
+                         mime_types: %w[all], compress_streams: true
+                log_requests before: { level: "INFO", format: "[{request_id}] {method} {path_and_query} - {addr} " },
+                             after: { level: "INFO",
+                                      format: "[{request_id}] └─ {status} in {response_time}" }
                 static_assets \
                   relative_path: true,
                   allowed_extensions: [],
-                  root_dir: '.',
-                  not_found_behavior: {error: 'not_found'},
+                  root_dir: ".",
+                  not_found_behavior: { error: "not_found" },
                   auto_index: true,
                   try_html_extension: true,
                   max_file_size_in_memory: 1024 * 1024, # 1MB
@@ -57,7 +60,7 @@ module Itsi
                   file_check_interval: 1,
                   serve_hidden_files: false,
                   headers: {
-                    'X-Content-Type-Options' => 'nosniff'
+                    "X-Content-Type-Options" => "nosniff"
                   }
               end
             end
@@ -69,7 +72,7 @@ module Itsi
               rackup_file args.fetch(:rackup_file, "./config.ru")
             end
           else
-            DSL.evaluate{}
+            DSL.evaluate {}
           end
 
         itsifile_config.transform_keys!(&:to_sym)
@@ -85,7 +88,7 @@ module Itsi
             Itsi.log_debug("Preloading middleware and default rack app")
             preloaded_middleware = middleware_loader.call
             middleware_loader = -> { preloaded_middleware }
-          rescue StandardError => e
+          rescue Exception => e # rubocop:disable Lint/RescueException
             errors << [e, e.backtrace[0]]
           end
         # If we're just preloading a specific gem group, we'll do that here too
@@ -107,7 +110,13 @@ module Itsi
           worker_memory_limit: args.fetch(:worker_memory_limit) { itsifile_config.fetch(:worker_memory_limit, nil) },
           silence: args.fetch(:silence) { itsifile_config.fetch(:silence, false) },
           shutdown_timeout: args.fetch(:shutdown_timeout) { itsifile_config.fetch(:shutdown_timeout, 5) },
-          hooks: args[:hooks] && itsifile_config[:hooks] ? args[:hooks].merge(itsifile_config[:hooks]) : itsifile_config.fetch(:hooks, args[:hooks]),
+          hooks: if args[:hooks] && itsifile_config[:hooks]
+                   args[:hooks].merge(itsifile_config[:hooks])
+                 else
+                   itsifile_config.fetch(
+                     :hooks, args[:hooks]
+                   )
+                 end,
           preload: !!preload,
           request_timeout: itsifile_config.fetch(:request_timeout, nil),
           header_read_timeout: args.fetch(:header_read_timeout) { itsifile_config.fetch(:header_read_timeout, nil) },
@@ -132,53 +141,23 @@ module Itsi
           listeners: args.fetch(:listeners) { nil },
           reuse_address: itsifile_config.fetch(:reuse_address, true),
           reuse_port: itsifile_config.fetch(:reuse_port, true),
-          listen_backlog: itsifile_config.fetch(:listen_backlog, 1024 ),
+          listen_backlog: itsifile_config.fetch(:listen_backlog, 1024),
           nodelay: itsifile_config.fetch(:nodelay, true),
           recv_buffer_size: itsifile_config.fetch(:recv_buffer_size, 262_144)
         }.transform_keys(&:to_s)
 
-        error_lines = errors.flat_map do |(error, message)|
-            location =  message[/(.*?)\:in/,1]
-            file, lineno = location.split(":")
-            lineno = lineno.to_i
-            err_message = error.kind_of?(NoMethodError) ? error.detailed_message : error.message
-            file_lines = IO.readlines(file)
-            info_lines = if error.kind_of?(SyntaxError)
-              []
-            else
-              ([lineno-2, 0].max...[file_lines.length, lineno.succ.succ].min).map do |currline|
-                if currline == lineno-1
-                  line = file_lines[currline][0...-1]
-                  padding = line[/^\s+/]&.length || 0
-
-                  [
-                    " \e[31m#{currline.succ.to_s.rjust(3)} | #{line}\e[0m",
-                    "     | #{' ' * padding}\e[33m^^^\e[0m "
-                  ]
-                else
-                  " #{currline.succ.to_s.rjust(3)} | #{file_lines[currline][0...-1]}"
-                end
-              end.flatten
-            end
-            [
-              err_message,
-              "   --> #{File.expand_path(file)}:#{lineno}",
-              *info_lines
-            ]
-          end
-
-        return srv_config, error_lines
-      rescue
+        [srv_config, errors_to_error_lines(errors)]
+      rescue StandardError
         Itsi.log_error e.message
         puts e.backtrace
       end
 
       def self.test!(cli_params)
-        _, errors = build_config(cli_params, Itsi::Server::Config.config_file_path(cli_params[:config_file]))
+        config, errors = build_config(cli_params, Itsi::Server::Config.config_file_path(cli_params[:config_file]))
         unless errors.any?
           begin
-            _["middleware_loader"][]
-          rescue Exception => e
+            config["middleware_loader"][]
+          rescue Exception => e # rubocop:disable Lint/RescueException
             errors = [e]
           end
         end
@@ -191,6 +170,42 @@ module Itsi
         end
       end
 
+      def self.errors_to_error_lines(errors)
+        return unless errors
+
+        errors.flat_map do |(error, message)|
+          location = message[/(.*?):in/, 1]
+          file, lineno = location.split(":")
+          lineno = lineno.to_i
+          err_message = error.is_a?(NoMethodError) ? error.detailed_message : error.message
+          file_lines = IO.readlines(file)
+          info_lines = \
+            if error.is_a?(SyntaxError)
+              []
+            else
+
+              ([lineno - 2, 0].max...[file_lines.length, lineno.succ.succ].min).map do |currline|
+                if currline == lineno - 1
+                  line = file_lines[currline][0...-1]
+                  padding = line[/^\s+/]&.length || 0
+
+                  [
+                    " \e[31m#{currline.succ.to_s.rjust(3)} | #{line}\e[0m",
+                    "     | #{" " * padding}\e[33m^^^\e[0m "
+                  ]
+                else
+                  " #{currline.succ.to_s.rjust(3)} | #{file_lines[currline][0...-1]}"
+                end
+              end.flatten
+            end
+          [
+            err_message,
+            "   --> #{File.expand_path(file)}:#{lineno}",
+            *info_lines
+          ]
+        end
+      end
+
       # Reloads the entire process
       # using exec, passing in any active file descriptors
       # and previous invocation arguments
@@ -233,56 +248,56 @@ module Itsi
 
         default_config = IO.read("#{__dir__}/default_config/Itsi.rb")
 
-        if File.exist?("./config.ru")
-          default_config << <<~RUBY
-          # You can mount several Ruby apps as either
-          # 1. rackup files
-          # 2. inline rack apps
-          # 3. inline Ruby endpoints
-          #
-          # 1. rackup_file
-          rackup_file "./config.ru"
-          #
-          # 2. inline rack app
-          # require 'rack'
-          # run(Rack::Builder.app do
-          #   use Rack::CommonLogger
-          #   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
-          # end)
-          #
-          # 3. Endpoints
-          # endpoint "/" do |req|
-          #   req.ok "Hello from Itsi"
-          # end
-          RUBY
-        else
-          default_config << <<~RUBY
-            # You can mount several Ruby apps as either
-            # 1. rackup files
-            # 2. inline rack apps
-            # 3. inline Ruby endpoints
-            #
-            # 1. rackup_file
-            # Use `rackup_file` to specify the Rack app file name.
-            #
-            # 2. inline rack app
-            # require 'rack'
-            # run(Rack::Builder.app do
-            #   use Rack::CommonLogger
-            #   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
-            # end)
-            #
-            # 3. Endpoint
-            endpoint "/" do |req|
-              req.ok "Hello from Itsi"
-            end
-          RUBY
-        end
+        default_config << \
+          if File.exist?("./config.ru")
+            <<~RUBY
+              # You can mount several Ruby apps as either
+              # 1. rackup files
+              # 2. inline rack apps
+              # 3. inline Ruby endpoints
+              #
+              # 1. rackup_file
+              rackup_file "./config.ru"
+              #
+              # 2. inline rack app
+              # require 'rack'
+              # run(Rack::Builder.app do
+              #   use Rack::CommonLogger
+              #   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
+              # end)
+              #
+              # 3. Endpoints
+              # endpoint "/" do |req|
+              #   req.ok "Hello from Itsi"
+              # end
+            RUBY
+          else
+            <<~RUBY
+              # You can mount several Ruby apps as either
+              # 1. rackup files
+              # 2. inline rack apps
+              # 3. inline Ruby endpoints
+              #
+              # 1. rackup_file
+              # Use `rackup_file` to specify the Rack app file name.
+              #
+              # 2. inline rack app
+              # require 'rack'
+              # run(Rack::Builder.app do
+              #   use Rack::CommonLogger
+              #   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
+              # end)
+              #
+              # 3. Endpoint
+              endpoint "/" do |req|
+                req.ok "Hello from Itsi"
+              end
+            RUBY
+          end
 
         File.open(ITSI_DEFAULT_CONFIG_FILE, "w") do |file|
           file.write(default_config)
         end
-
       end
     end
   end

data/gems/server/lib/itsi/server/default_app/default_app.rb

@@ -11,7 +11,7 @@ DEFAULT_APP = lambda {
         [
           { "Content-Type" => "application/json" },
           [{ "message" => "You're running on Itsi!", "rack_env" => env,
-              "version" => Itsi::Server::VERSION }.to_json]
+             "version" => Itsi::Server::VERSION }.to_json]
         ]
       else
         [

data/gems/server/lib/itsi/server/grpc/grpc_call.rb

@@ -7,11 +7,11 @@ module Itsi
     attr_accessor :rpc_desc
 
     def input_stream?
-      @input_stream ||= @rpc_desc&.input&.is_a?(GRPC::RpcDesc::Stream) || false
+      @input_stream ||= @rpc_desc&.input.is_a?(GRPC::RpcDesc::Stream) || false
     end
 
     def output_stream?
-      @output_stream ||= @rpc_desc&.output&.is_a?(GRPC::RpcDesc::Stream) || false
+      @output_stream ||= @rpc_desc&.output.is_a?(GRPC::RpcDesc::Stream) || false
     end
 
     def input_type
@@ -64,7 +64,7 @@ module Itsi
       return nil if first_char.nil?
 
       # Step 2: Process objects until we hit the end of the JSON stream or array.
-      loop do
+      loop do # rubocop:disable Lint/UnreachableLoop,Metrics/BlockLength
         # Skip any whitespace or commas preceding an object.
         char = nil
         loop do
@@ -89,7 +89,6 @@ module Itsi
 
           buffer << ch
 
-
           if in_string
             if escape
               escape = false
@@ -120,7 +119,7 @@ module Itsi
     def remote_read
       if content_type == "application/json"
         if input_stream?
-          if next_item = parse_from_json_stream(reader)
+          if (next_item = parse_from_json_stream(reader))
             input_type.decode_json(next_item)
           end
         else

data/gems/server/lib/itsi/server/grpc/grpc_interface.rb

@@ -29,7 +29,6 @@ module Itsi
       end
 
       def handle_request(active_call)
-        puts "Handling active call"
         unless (active_call.rpc_desc = @rpc_descs[active_call.method_name])
           active_call.stream.write("\n")
           active_call.send_status(13, "Method not found")
@@ -89,18 +88,18 @@ module Itsi
         result = service.send(active_call.method_name, message, active_call) do |response|
           active_call.remote_send(response)
         end
-        if result.kind_of?(Enumerator)
-          result.each { |response| active_call.remote_send(response) }
-        end
+        return unless result.is_a?(Enumerator)
+
+        result.each { |response| active_call.remote_send(response) }
       end
 
       def handle_bidi_streaming(active_call)
         result = service.send(active_call.method_name, active_call.each_remote_read, active_call) do |response|
           active_call.remote_send(response)
         end
-        if result.kind_of?(Enumerator)
-          result.each { |response| active_call.remote_send(response) }
-        end
+        return unless result.is_a?(Enumerator)
+
+        result.each { |response| active_call.remote_send(response) }
       end
     end
   end

data/gems/server/lib/itsi/server/rack/handler/itsi.rb

@@ -1,6 +1,5 @@
 return unless defined?(::Rackup::Handler) || defined?(Rack::Handler)
 
-
 module Rack
   module Handler
     module Itsi

data/gems/server/lib/itsi/server/rack_interface.rb

@@ -1,14 +1,13 @@
 module Itsi
   class Server
     module RackInterface
-
       # Builds a handler proc that is compatible with Rack applications.
       def self.for(app)
         require "rack"
         if app.is_a?(String)
           dir = File.expand_path(File.dirname(app))
           Dir.chdir(dir) do
-            loaded_app = ::Rack::Builder.parse_file(app)
+            loaded_app = ::Rack::Builder.parse_file(File.basename(app))
             app = loaded_app.is_a?(Array) ? loaded_app.first : loaded_app
           end
         end

data/gems/server/lib/itsi/server/route_tester.rb

@@ -1,53 +1,55 @@
 module Itsi
   class Server
+    # Utility module for printing Itsi route information
     module RouteTester
-
       require "set"
       require "strscan"
-      require "debug"
+
       def format_mw(mw)
         mw_name, mw_args = mw
         case mw_name
         when "app"
-          "\e[33mapp\e[0m(#{mw_args['app_proc'].inspect.split(' ')[1][0...-1]})"
+          "\e[33mapp\e[0m(#{mw_args["app_proc"].inspect.split(" ")[1][0...-1]})"
         when "log_requests"
-          if mw_args['before'] && mw_args['after']
-            "\e[33mlog_requests\e[0m(before: #{mw_args['before']['format'][0..6]}..., after: #{mw_args['after']['format'][0..6]}...)"
-          elsif mw_args['before']
-            "\e[33mlog_requests\e[0m(before: #{mw_args['before']['format'][0..6]}...)"
-          elsif mw_args['after']
-            "\e[33mlog_requests\e[0m(before: nil, after: #{mw_args['after']['format'][0..6]}...)"
+          if mw_args["before"] && mw_args["after"]
+            "\e[33mlog_requests\e[0m(before: #{mw_args["before"]["format"][0..6]}..., after: #{mw_args["after"]["format"][0..6]}...)"
+          elsif mw_args["before"]
+            "\e[33mlog_requests\e[0m(before: #{mw_args["before"]["format"][0..6]}...)"
+          elsif mw_args["after"]
+            "\e[33mlog_requests\e[0m(before: nil, after: #{mw_args["after"]["format"][0..6]}...)"
           end
         when "compress"
-          "\e[33mcompress\e[0m(#{mw_args['algorithms'].join(' ')}, #{mw_args['mime_types']})"
+          "\e[33mcompress\e[0m(#{mw_args["algorithms"].join(" ")}, #{mw_args["mime_types"]})"
         when "cors"
-          "\e[33mcors\e[0m(#{mw_args['allow_origins'].join(' ')}, #{mw_args['allow_methods'].join(' ')})"
+          "\e[33mcors\e[0m(#{mw_args["allow_origins"].join(" ")}, #{mw_args["allow_methods"].join(" ")})"
         when "etag"
-          "\e[33metag\e[0m(#{mw_args['type']}/#{mw_args['algorithm']}, #{mw_args['handle_if_none_match'] ? 'if_none_match' : ''})"
+          "\e[33metag\e[0m(#{mw_args["type"]}/#{mw_args["algorithm"]}, #{mw_args["handle_if_none_match"] ? "if_none_match" : ""})"
         when "cache_control"
-          "\e[33mcache_control\e[0m(max_age: #{mw_args['max_age']}, #{mw_args.select{|_,v| v == true }.keys.join(", ")})"
+          "\e[33mcache_control\e[0m(max_age: #{mw_args["max_age"]}, #{mw_args.select do |_, v|
+            v == true
+          end.keys.join(", ")})"
         when "redirect"
-          "\e[33mredirect\e[0m(to: #{mw_args['to']}, type: #{mw_args['type']})"
+          "\e[33mredirect\e[0m(to: #{mw_args["to"]}, type: #{mw_args["type"]})"
         when "static_assets"
-          "\e[33mstatic_assets\e[0m(path: #{mw_args['root_dir']})"
+          "\e[33mstatic_assets\e[0m(path: #{mw_args["root_dir"]})"
         when "auth_api_key"
-          "\e[33mauth_api_key\e[0m(keys: #{mw_args['valid_keys'].keys}#{mw_args['credentials_file'] ? ", credentials_file: #{mw_args['credentials_file']}" : ""})"
+          "\e[33mauth_api_key\e[0m(keys: #{mw_args["valid_keys"].keys}#{mw_args["credentials_file"] ? ", credentials_file: #{mw_args["credentials_file"]}" : ""})"
         when "auth_basic"
-          "\e[33mbasic_auth\e[0m(keys: #{mw_args['realm']}#{mw_args['credentials_file'] ? ", credentials_file: #{mw_args['credentials_file']}" : ""})"
+          "\e[33mbasic_auth\e[0m(keys: #{mw_args["realm"]}#{mw_args["credentials_file"] ? ", credentials_file: #{mw_args["credentials_file"]}" : ""})"
         when "auth_jwt"
-          "\e[33mjwt_auth\e[0m(#{mw_args['verifiers'].keys.join(",")})"
+          "\e[33mjwt_auth\e[0m(#{mw_args["verifiers"].keys.join(",")})"
         when "rate_limit"
-          key = mw_args['key'].kind_of?(Hash) ? mw_args['key']["parameter"] : mw_args['key']
-          "\e[33mrate_limit\e[0m(rps: #{mw_args['requests']}/#{mw_args['seconds']}, key: #{key})"
+          key = mw_args["key"].is_a?(Hash) ? mw_args["key"]["parameter"] : mw_args["key"]
+          "\e[33mrate_limit\e[0m(rps: #{mw_args["requests"]}/#{mw_args["seconds"]}, key: #{key})"
         when "allow_list"
-          "\e[33mallow_list\e[0m(patterns: #{mw_args['allowed_patterns'].join(", ")})"
+          "\e[33mallow_list\e[0m(patterns: #{mw_args["allowed_patterns"].join(", ")})"
         when "deny_list"
-          "\e[33mdeny_list\e[0m(patterns: #{mw_args['denied_patterns'].join(", ")})"
+          "\e[33mdeny_list\e[0m(patterns: #{mw_args["denied_patterns"].join(", ")})"
         when "csp"
-          "\e[33mcsp\e[0m(#{mw_args['policy'].map{|k,v| "#{k}: #{v.join(",")}"}.join(", ")})"
+          "\e[33mcsp\e[0m(#{mw_args["policy"].map { |k, v| "#{k}: #{v.join(",")}" }.join(", ")})"
         when "intrusion_protection"
           [mw_args].flatten.map do |mw_args|
-            "\e[33mintrusion_protection\e[0m(banned_url_patterns: #{mw_args['banned_url_patterns']&.length}, banned_header_patterns: #{mw_args['banned_header_patterns']&.keys&.join(", ")}, #{mw_args['banned_time_seconds']}s)"
+            "\e[33mintrusion_protection\e[0m(banned_url_patterns: #{mw_args["banned_url_patterns"]&.length}, banned_header_patterns: #{mw_args["banned_header_patterns"]&.keys&.join(", ")}, #{mw_args["banned_time_seconds"]}s)"
           end.join("\n")
         when "request_headers"
           [mw_args].flatten.map do |mw_args|

data/gems/server/lib/itsi/server/typed_handlers/param_parser.rb

@@ -143,6 +143,31 @@ module Itsi
         # Fixed keys are converted to symbols, and regex-matched keys remain as strings.
         # The current location in the params is tracked as an array of path segments.
         def apply_schema!(params, schema, path = [])
+          # Support top-level array schema: homogeneous arrays.
+          if schema.is_a?(Array)
+            # Only allow homogeneous array types
+            unless schema.size == 1
+              raise ValidationError.new(["Schema Array must contain exactly one type. Got #{schema.size}"])
+            end
+            expected_type = schema.first
+            # Expect params to be an Array
+            unless params.is_a?(Array)
+              raise ValidationError.new(["Expected Array at #{format_path(path)}, got #{params.class}"])
+            end
+            errors = []
+            params.each_with_index do |_, idx|
+              err = cast_value!(params, idx, expected_type, path + [idx])
+              errors << err if err
+            end
+            raise ValidationError.new(errors) unless errors.empty?
+            return params
+          end
+
+          # Ensure schema is a Hash
+          unless schema.is_a?(Hash)
+            raise ValidationError.new(["Unsupported schema type: #{schema.class} at #{format_path(path)}"])
+          end
+
           errors = []
           processed = processed_schema(schema)
           fixed_schema = processed[0]