itsi 0.1.14 → 0.1.18

data/gems/server/lib/itsi/server/grpc/reflection/v1/reflection_pb.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: reflection.proto
+
+require 'google/protobuf'
+require "google/protobuf/descriptor_pb"
+
+descriptor_data = "\n\x10reflection.proto\x12\x12grpc.reflection.v1\"\x85\x02\n\x17ServerReflectionRequest\x12\x0c\n\x04host\x18\x01 \x01(\t\x12\x1a\n\x10\x66ile_by_filename\x18\x03 \x01(\tH\x00\x12 \n\x16\x66ile_containing_symbol\x18\x04 \x01(\tH\x00\x12I\n\x19\x66ile_containing_extension\x18\x05 \x01(\x0b\x32$.grpc.reflection.v1.ExtensionRequestH\x00\x12\'\n\x1d\x61ll_extension_numbers_of_type\x18\x06 \x01(\tH\x00\x12\x17\n\rlist_services\x18\x07 \x01(\tH\x00\x42\x11\n\x0fmessage_request\"E\n\x10\x45xtensionRequest\x12\x17\n\x0f\x63ontaining_type\x18\x01 \x01(\t\x12\x18\n\x10\x65xtension_number\x18\x02 \x01(\x05\"\xb8\x03\n\x18ServerReflectionResponse\x12\x12\n\nvalid_host\x18\x01 \x01(\t\x12\x45\n\x10original_request\x18\x02 \x01(\x0b\x32+.grpc.reflection.v1.ServerReflectionRequest\x12N\n\x18\x66ile_descriptor_response\x18\x04 \x01(\x0b\x32*.grpc.reflection.v1.FileDescriptorResponseH\x00\x12U\n\x1e\x61ll_extension_numbers_response\x18\x05 \x01(\x0b\x32+.grpc.reflection.v1.ExtensionNumberResponseH\x00\x12I\n\x16list_services_response\x18\x06 \x01(\x0b\x32\'.grpc.reflection.v1.ListServiceResponseH\x00\x12;\n\x0e\x65rror_response\x18\x07 \x01(\x0b\x32!.grpc.reflection.v1.ErrorResponseH\x00\x42\x12\n\x10message_response\"7\n\x16\x46ileDescriptorResponse\x12\x1d\n\x15\x66ile_descriptor_proto\x18\x01 \x03(\x0c\"K\n\x17\x45xtensionNumberResponse\x12\x16\n\x0e\x62\x61se_type_name\x18\x01 \x01(\t\x12\x18\n\x10\x65xtension_number\x18\x02 \x03(\x05\"K\n\x13ListServiceResponse\x12\x34\n\x07service\x18\x01 \x03(\x0b\x32#.grpc.reflection.v1.ServiceResponse\"\x1f\n\x0fServiceResponse\x12\x0c\n\x04name\x18\x01 \x01(\t\":\n\rErrorResponse\x12\x12\n\nerror_code\x18\x01 \x01(\x05\x12\x15\n\rerror_message\x18\x02 \x01(\t2\x89\x01\n\x10ServerReflection\x12u\n\x14ServerReflectionInfo\x12+.grpc.reflection.v1.ServerReflectionRequest\x1a,.grpc.reflection.v1.ServerReflectionResponse(\x01\x30\x01\x42\x66\n\x15io.grpc.reflection.v1B\x15ServerReflectionProtoP\x01Z4google.golang.org/grpc/reflection/grpc_reflection_v1b\x06proto3"
+
+pool = Google::Protobuf::DescriptorPool.generated_pool
+pool.add_serialized_file(descriptor_data)
+
+module Grpc
+  module Reflection
+    module V1
+      ServerReflectionRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.reflection.v1.ServerReflectionRequest").msgclass
+      ExtensionRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.reflection.v1.ExtensionRequest").msgclass
+      ServerReflectionResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.reflection.v1.ServerReflectionResponse").msgclass
+      FileDescriptorResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.reflection.v1.FileDescriptorResponse").msgclass
+      ExtensionNumberResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.reflection.v1.ExtensionNumberResponse").msgclass
+      ListServiceResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.reflection.v1.ListServiceResponse").msgclass
+      ServiceResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.reflection.v1.ServiceResponse").msgclass
+      ErrorResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.reflection.v1.ErrorResponse").msgclass
+    end
+  end
+end

data/gems/server/lib/itsi/server/grpc/reflection/v1/reflection_services_pb.rb

@@ -0,0 +1,122 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# Source: reflection.proto for package 'grpc.reflection.v1'
+# Original file comments:
+# Copyright 2016 The gRPC Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Service exported by server reflection.  A more complete description of how
+# server reflection works can be found at
+# https://github.com/grpc/grpc/blob/master/doc/server-reflection.md
+#
+# The canonical version of this proto can be found at
+# https://github.com/grpc/grpc-proto/blob/master/grpc/reflection/v1/reflection.proto
+#
+
+require "grpc"
+require_relative "reflection_pb"
+
+module Grpc
+  module Reflection
+    module V1
+      module ServerReflection
+        class Service
+          include ::GRPC::GenericService
+
+          self.marshal_class_method = :encode
+          self.unmarshal_class_method = :decode
+          self.service_name = "grpc.reflection.v1.ServerReflection"
+
+          # The reflection service is structured as a bidirectional stream, ensuring
+          # all related requests go to a single server.
+          rpc :ServerReflectionInfo, stream(::Grpc::Reflection::V1::ServerReflectionRequest),
+              stream(::Grpc::Reflection::V1::ServerReflectionResponse)
+
+          def initialize(handlers)
+            @handlers = handlers
+            super()
+          end
+
+          def server_reflection_info(req, _unused_call)
+            req.each do |request|
+              res = Grpc::Reflection::V1::ServerReflectionResponse.new
+
+              if !request.list_services.empty?
+                res.list_services_response = Grpc::Reflection::V1::ListServiceResponse.new(service: list_services_response)
+              elsif !request.file_containing_symbol.empty?
+                res.file_descriptor_response = Grpc::Reflection::V1::FileDescriptorResponse.new(
+                  file_descriptor_proto: [
+                    Google::Protobuf::FileDescriptorProto.encode(Google::Protobuf::DescriptorPool.generated_pool.lookup(request.file_containing_symbol).file_descriptor.to_proto)
+                  ]
+                )
+              elsif !request.file_by_filename.empty?
+                # Handle file_by_filename requests
+                file_descriptor = find_file_descriptor_by_filename(request.file_by_filename)
+                if file_descriptor
+                  res.file_descriptor_response = Grpc::Reflection::V1::FileDescriptorResponse.new(
+                    file_descriptor_proto: [Google::Protobuf::FileDescriptorProto.encode(file_descriptor)]
+                  )
+                else
+                  res.error_response = Grpc::Reflection::V1::ErrorResponse.new(
+                    error_code: 5, # NOT_FOUND
+                    error_message: "File not found: #{request.file_by_filename}"
+                  )
+                end
+              end
+              yield res
+              # We can loop here if running in Fiber mode, but for best compatibility with blocking IO modes
+              # we'll close the connection and force the client to reconnect force
+              # subsequent reflection requests
+              break
+            end
+          end
+
+          def find_file_descriptor_by_filename(filename)
+            # First try direct lookup in the pool
+
+            descriptor = Google::Protobuf::DescriptorPool.generated_pool.lookup(filename)&.file_descriptor
+            return descriptor.to_proto if descriptor
+
+            proto_name = convert_file_path_to_proto_name(filename)
+            descriptor = Google::Protobuf::DescriptorPool.generated_pool.lookup(proto_name)&.file_descriptor
+            return descriptor.to_proto if descriptor
+
+            nil
+          end
+
+          def convert_file_path_to_proto_name(file_path)
+            # Remove .proto extension
+            file_path = file_path.sub(/\.proto$/, "")
+
+            # Split path into parts
+            parts = file_path.split("/")
+
+            # Convert last part to PascalCase (e.g., money -> Money)
+            parts[-1] = parts[-1].split("_").map(&:capitalize).join
+
+            # Join with dots
+            parts.join(".")
+          end
+
+          def list_services_response
+            @list_services_response ||= @handlers.map(&:class).map(&:service_name).map do |name|
+              Grpc::Reflection::V1::ServiceResponse.new(name: name)
+            end
+          end
+        end
+
+        Stub = Service.rpc_stub_class
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+module Itsi
+  class Server
+    module RouteTester
+
+      require "set"
+      require "strscan"
+
+      def format_mw(mw)
+        case mw["type"]
+        when "app"
+          "app #{mw["parameters"]["app_proc"].inspect.split(" ")[1]}"
+        else
+          mw["type"]
+        end
+      end
+
+      def print_route(route_str, stack)
+        filters = %w[methods ports protocols extensions].map do |key|
+          val = stack[key]
+          val ? "#{key}: #{Array(val).join(",")}" : nil
+        end.compact
+        filter_str = filters.any? ? filters.join(", ") : "(none)"
+
+        middlewares = stack["middleware"]
+
+        puts "─" * 76
+        puts "Route:      #{route_str}"
+        puts "Conditions: #{filter_str}"
+        puts "Middleware: • #{format_mw(middlewares.first)}"
+        middlewares[1..].each do |mw|
+          puts "            • #{format_mw(mw)}"
+        end
+      end
+
+      def explode_route_pattern(pattern)
+        pattern = pattern.gsub(/^\^|\$$/, "")
+        pattern = pattern.gsub("\\", "")
+        tokens = parse_expression(StringScanner.new(pattern))
+        expand_tokens(tokens)
+      end
+
+      # Parses the expression into a nested tree of tokens
+      def parse_expression(scanner)
+        tokens = []
+        buffer = ""
+
+        until scanner.eos?
+          if scanner.scan(/\(\?:/)
+            tokens << buffer unless buffer.empty?
+            buffer = ""
+            tokens << parse_alternation(scanner)
+          elsif scanner.peek(1) == ")"
+            scanner.getch # consume ')'
+            break
+          else
+            buffer << scanner.getch
+          end
+        end
+
+        tokens << buffer unless buffer.empty?
+        tokens
+      end
+
+      # Parses inside a non-capturing group (?:A|B|C)
+      def parse_alternation(scanner)
+        options = []
+        current = []
+
+        until scanner.eos?
+          if scanner.scan(/\(\?:/)
+            current << parse_alternation(scanner)
+          elsif scanner.peek(1) == ")"
+            scanner.getch # consume ')'
+            break
+          elsif scanner.peek(1) == "|"
+            scanner.getch # consume '|'
+            options << current
+            current = []
+          else
+            current << scanner.getch
+          end
+        end
+
+        options << current
+        { alt: options }
+      end
+
+      def expand_tokens(tokens)
+        parts = tokens.map do |token|
+          if token.is_a?(String)
+            [token]
+          elsif token.is_a?(Hash) && token[:alt]
+            # Recurse into each branch of the alternation
+            token[:alt].map { |branch| expand_tokens(branch) }.flatten
+          else
+            raise "Unexpected token: #{token.inspect}"
+          end
+        end
+
+        # Cartesian product of all parts
+        parts.inject([""]) do |acc, part|
+          acc.product(part).map { |a, b| a + b }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,200 @@
+module Itsi
+  class Server
+    module TypedHandlers
+      module ParamParser
+        require 'date'
+
+        class ValidationError < StandardError
+          attr_reader :errors
+          def initialize(errors)
+            @errors = errors
+            super("Validation failed: #{errors.join('; ')}")
+          end
+        end
+
+        # Conversion map for primitive/base type conversions.
+        CONVERSION_MAP = {
+          String    => ->(v){ v.to_s },
+          Symbol    => ->(v){ v.to_sym },
+          Integer   => ->(v){ Integer(v) },
+          Float     => ->(v){ Float(v) },
+          :Number   => ->(v){ Float(v) },
+          TrueClass => ->(v){
+            case v
+            when true, 'true', '1', 1 then true
+            when false, 'false', '0', 0 then false
+            else raise "Cannot cast #{v.inspect} to Boolean"
+            end
+          },
+          FalseClass => ->(v){
+            case v
+            when true, 'true', '1', 1 then true
+            when false, 'false', '0', 0 then false
+            else raise "Cannot cast #{v.inspect} to Boolean"
+            end
+          },
+          :Boolean  => ->(v){
+            case v
+            when true, 'true', '1', 1 then true
+            when false, 'false', '0', 0 then false
+            else raise "Cannot cast #{v.inspect} to Boolean"
+            end
+          },
+          Date      => ->(v){ Date.parse(v.to_s) },
+          Time      => ->(v){ Time.parse(v.to_s) },
+          DateTime  => ->(v){ DateTime.parse(v.to_s) }
+        }.compare_by_identity
+
+        # Extracts the expected type and required flag from a schema definition.
+        def extract_schema(schema_def)
+          if schema_def.is_a?(Hash) && schema_def.key?(:_type)
+            expected_type = schema_def[:_type]
+            required = schema_def.fetch(:required, true)
+            [expected_type, required]
+          else
+            [schema_def, true]
+          end
+        end
+
+        # Preprocess the schema into fixed keys (as symbols) and regex keys.
+        # Memoizes the result based on the schema.
+        def processed_schema(schema)
+          @@schema_cache ||= {}
+          @@schema_cache[schema] ||= begin
+            fixed = {}
+            regex = []
+            schema.each do |k, schema_def|
+              expected_type, required = extract_schema(schema_def)
+              if k.is_a?(Regexp)
+                regex << [k, [expected_type, required]]
+              else
+                fixed[k.to_sym] = [expected_type, required]
+              end
+            end
+            [fixed, regex]
+          end
+        end
+
+        # Helper that converts an array of path segments into a string.
+        # For example, [:user, "addresses", 0, :street] becomes "user.addresses[0].street".
+        def format_path(path)
+          result = "".dup
+          path.each do |seg|
+            if seg.is_a?(Integer)
+              result << "[#{seg}]"
+            else
+              result << (result.empty? ? seg.to_s : ".#{seg}")
+            end
+          end
+          result
+        end
+
+        # In-place casts the value at container[key] according to expected_type.
+        # On success, updates container[key] and returns nil.
+        # On failure, returns an error message string that uses the formatted path.
+        def cast_value!(container, key, expected_type, path)
+          if expected_type.is_a?(Array)
+            # Only allow homogeneous array types.
+            return "Only homogeneous array types are supported at #{format_path(path)}" if expected_type.size != 1
+
+            # Expect container[key] to be an Array; process each element in place.
+            unless container[key].is_a?(Array)
+              return "Expected an Array at #{format_path(path)}, got #{container[key].class}"
+            end
+            container[key].each_with_index do |_, idx|
+              err = cast_value!(container[key], idx, expected_type.first, path + [idx])
+              return err if err
+            end
+            return nil
+
+          elsif expected_type.is_a?(Hash)
+            # Nested schema: expect container[key] to be a Hash; process it in place.
+            unless container[key].is_a?(Hash)
+              return "Expected a Hash at #{format_path(path)}, got #{container[key].class}"
+            end
+            begin
+              apply_schema!(container[key], expected_type, path)
+              return nil
+            rescue ValidationError => ve
+              return ve.errors.join('; ')
+            end
+
+          else
+            converter = CONVERSION_MAP[expected_type]
+            if converter
+              begin
+                container[key] = converter.call(container[key])
+                return nil
+              rescue => e
+                return "Invalid value for #{expected_type} at #{format_path(path)}: #{container[key].inspect} (#{e.message})"
+              end
+            end
+
+            # Fallbacks.
+            if expected_type == Array
+              unless container[key].is_a?(Array)
+                return "Expected Array at #{format_path(path)}, got #{container[key].class}"
+              end
+              return nil
+            elsif expected_type == Hash
+              unless container[key].is_a?(Hash)
+                return "Expected Hash at #{format_path(path)}, got #{container[key].class}"
+              end
+              return nil
+            elsif expected_type == File && container[key].is_a?(Hash) && container[key][:tempfile].is_a?(Tempfile)
+              return nil
+            else
+              return "Unsupported type: #{expected_type.inspect} at #{format_path(path)}"
+            end
+          end
+        end
+
+        # Applies the schema in place to the given params hash.
+        # 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 = [])
+          errors = []
+          processed = processed_schema(schema)
+          fixed_schema = processed[0]
+          regex_schema = processed[1]
+
+          # Process fixed keys.
+          fixed_schema.each do |fixed_key, (expected_type, required)|
+            new_path = path + [fixed_key]
+            if params.key?(fixed_key)
+              # Symbol key present.
+            elsif params.key?(fixed_key.to_s)
+              params[fixed_key] = params.delete(fixed_key.to_s)
+            else
+              if required
+                errors << "Missing required key: #{format_path(new_path)}"
+              else
+                params[fixed_key] = nil
+              end
+              next
+            end
+
+            err = cast_value!(params, fixed_key, expected_type, new_path)
+            errors << err if err
+          end
+
+          # Process regex keys (only string keys not already handled as fixed keys).
+          params.keys.select { |k| k.is_a?(String) }.each do |key|
+            next if fixed_schema.has_key?(key.to_sym) || fixed_schema.has_key?(key)
+            regex_schema.each do |regex, (expected_type, _required)|
+              if regex.match(key)
+                new_path = path + [key]
+                err = cast_value!(params, key, expected_type, new_path)
+                errors << err if err
+                break  # only use the first matching regex
+              end
+            end
+          end
+
+          raise ValidationError.new(errors) unless errors.empty?
+          params
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Itsi
+  class Server
+    module TypedHandlers
+      module SourceParser
+        require 'prism'
+
+
+        def self.extract_expr_from_source_location(proc)
+          source_lines = IO.readlines(proc.source_location.first)
+
+          proc_line = source_location.last - 1
+          first_line = source_lines[proc_line]
+          binding.b
+          until first_line =~ /(?:lambda|proc|->|def|.*?do\s*\|)/ || proc_line.zero?
+            proc_line -= 1
+            first_line = source_lines[proc_line]
+          end
+          lines = source_lines[proc_line..]
+          lines[0] = lines[0][/(?:lambda|proc|->|def|.*?do\s*\|).*/]
+          src_str = lines.first << "\n"
+          intermediate = Prism.parse(src_str)
+
+          lines[1..-1].each do |line|
+            break if intermediate.success?
+            token_count = 0
+            line.split(/(?=\s|;|\)|\})/).each do |token|
+              src_str << token
+              token_count += 1
+              intermediate = Prism.parse(src_str)
+              next unless intermediate.success? && token_count > 1
+              break
+            end
+          end
+
+          raise 'Source Extraction Failed' unless intermediate.success?
+
+          src = intermediate.value.statements.body.first.yield_self do |s|
+            s.type == :call_node ? s.block : s
+          end
+          params = src.parameters
+          params = params.parameters if params.respond_to?(:parameters)
+          requireds = (params&.requireds || []).map(&:name)
+          optionals = params&.optionals || []
+          keywords =  (params&.keywords || []).map do |kw|
+            [kw.name, kw.value.slice.gsub(/^_\./, '$.')]
+          end.to_h
+
+          [requireds.length, keywords]
+        rescue
+          [ proc.parameters.first&.length || 0, {}]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require_relative "typed_handlers/source_parser"
+require_relative "typed_handlers/param_parser"
+
+module Itsi
+  class Server
+    module TypedHandlers
+      def self.handler_for(proc, input_schema)
+        input_schema = proc.binding.eval(input_schema) if input_schema
+        lambda do |req|
+          req.params(input_schema) do |params|
+            proc.call(req, params: params)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,6 @@
 
 module Itsi
   class Server
-    VERSION = "0.1.14"
+    VERSION = "0.1.18"
   end
 end