rapitapir 0.1.0

data/lib/rapitapir/server/enhanced_rack_adapter.rb

@@ -0,0 +1,379 @@
+# frozen_string_literal: true
+
+require 'rack'
+require 'json'
+require_relative '../core/enhanced_endpoint'
+require_relative '../dsl/enhanced_endpoint_dsl'
+require_relative 'path_matcher'
+
+module RapiTapir
+  module Server
+    # Enhanced Rack adapter that integrates with the new type system
+    class EnhancedRackAdapter
+      attr_reader :endpoints, :middleware_stack, :error_handlers
+
+      def initialize
+        @endpoints = []
+        @middleware_stack = []
+        @error_handlers = {}
+      end
+
+      # Register an endpoint with a handler
+      def mount(endpoint, &handler)
+        raise ArgumentError, 'Endpoint must be provided' unless endpoint
+        raise ArgumentError, 'Handler block must be provided' unless block_given?
+
+        # Ensure we're working with an enhanced endpoint
+        enhanced_endpoint = case endpoint
+                            when Core::EnhancedEndpoint
+                              endpoint
+                            when Core::Endpoint
+                              # Convert regular endpoint to enhanced endpoint
+                              convert_to_enhanced(endpoint)
+                            else
+                              raise ArgumentError, 'Endpoint must be a RapiTapir::Core::Endpoint'
+                            end
+
+        enhanced_endpoint.validate!
+        path_matcher = PathMatcher.new(enhanced_endpoint.path)
+
+        @endpoints << {
+          endpoint: enhanced_endpoint,
+          handler: handler,
+          path_matcher: path_matcher
+        }
+      end
+
+      # Add middleware to the processing stack
+      def use(middleware_class, *args, &block)
+        @middleware_stack << [middleware_class, args, block]
+      end
+
+      # Register error handlers
+      def on_error(error_class, &handler)
+        @error_handlers[error_class] = handler
+      end
+
+      # Main Rack application call method
+      def call(env)
+        app = build_app
+        app.call(env)
+      end
+
+      # Build the complete middleware stack
+      def build_app
+        app = method(:handle_request)
+
+        @middleware_stack.reverse.each do |middleware_class, args, block|
+          app = middleware_class.new(app, *args, &block)
+        end
+
+        app
+      end
+
+      # Core request handler with enhanced type validation
+      def handle_request(env)
+        request = Rack::Request.new(env)
+
+        # Find matching endpoint
+        endpoint_match = find_matching_endpoint(request)
+        return not_found_response unless endpoint_match
+
+        begin
+          # Process the request through the endpoint with full validation
+          process_enhanced_request(request, endpoint_match)
+        rescue Core::EnhancedEndpoint::ValidationError => e
+          validation_error_response(e)
+        rescue Types::ValidationError => e
+          type_validation_error_response(e)
+        rescue Types::CoercionError => e
+          coercion_error_response(e)
+        rescue StandardError => e
+          handle_custom_error(e) || error_response(e)
+        end
+      end
+
+      private
+
+      def find_matching_endpoint(request)
+        @endpoints.find do |endpoint_data|
+          endpoint = endpoint_data[:endpoint]
+          path_matcher = endpoint_data[:path_matcher]
+          matches_method?(endpoint, request) && path_matcher.matches?(request.path_info)
+        end
+      end
+
+      def matches_method?(endpoint, request)
+        endpoint.method.to_s.upcase == request.request_method
+      end
+
+      def process_enhanced_request(request, endpoint_match)
+        endpoint = endpoint_match[:endpoint]
+        handler = endpoint_match[:handler]
+        path_matcher = endpoint_match[:path_matcher]
+
+        # Extract path parameters
+        path_params = path_matcher.match(request.path_info) || {}
+
+        # Extract and validate inputs using the enhanced type system
+        processed_inputs = extract_and_validate_inputs(request, endpoint, path_params)
+
+        # Validate the complete request
+        validated_inputs = endpoint.process_request(processed_inputs)
+
+        # Call the handler with validated inputs
+        result = handler.call(validated_inputs)
+
+        # Validate and serialize response
+        serialize_validated_response(result, endpoint)
+      end
+
+      def extract_and_validate_inputs(request, endpoint, path_params = {})
+        inputs = {}
+
+        endpoint.inputs.each do |input|
+          processed_input = process_single_input(request, input, path_params)
+          inputs.merge!(processed_input) if processed_input
+        end
+
+        inputs
+      end
+
+      def process_single_input(request, input, path_params)
+        value = extract_input_value(request, input, path_params)
+
+        # Handle required inputs
+        validate_required_input(input, value)
+
+        # Skip optional nil values
+        return nil if value.nil? && input.optional?
+
+        # Coerce and validate the value
+        coerced_value = coerce_and_validate_input(input, value)
+        { input.name => coerced_value }
+      end
+
+      def validate_required_input(input, value)
+        return unless value.nil? && input.required?
+
+        raise Core::EnhancedEndpoint::ValidationError, "Required input '#{input.name}' is missing"
+      end
+
+      def coerce_and_validate_input(input, value)
+        coerced_value = input.coerce(value)
+        validation_result = input.validate(coerced_value)
+
+        unless validation_result[:valid]
+          errors = validation_result[:errors].join(', ')
+          raise Core::EnhancedEndpoint::ValidationError, "Input '#{input.name}' validation failed: #{errors}"
+        end
+
+        coerced_value
+      rescue Types::CoercionError => e
+        raise Core::EnhancedEndpoint::ValidationError, "Input '#{input.name}' coercion failed: #{e.message}"
+      end
+
+      def extract_input_value(request, input, path_params)
+        case input.kind
+        when :query
+          request.params[input.name.to_s]
+        when :header
+          extract_header_value(request, input)
+        when :path
+          path_params[input.name]
+        when :body
+          parse_request_body(request, input)
+        end
+      end
+
+      def extract_header_value(request, input)
+        header_name = case input.name
+                      when :authorization
+                        'HTTP_AUTHORIZATION'
+                      else
+                        "HTTP_#{input.name.to_s.upcase.gsub('-', '_')}"
+                      end
+        request.get_header(header_name)
+      end
+
+      def parse_request_body(request, input)
+        body = request.body.read
+        request.body.rewind
+
+        return nil if body.empty?
+
+        content_type = request.content_type&.downcase
+        format = input.options[:format] || detect_format_from_content_type(content_type)
+
+        case format
+        when :json
+          JSON.parse(body)
+        when :form
+          Rack::Utils.parse_nested_query(body)
+        else
+          body
+        end
+      rescue JSON::ParserError => e
+        raise Core::EnhancedEndpoint::ValidationError, "Invalid JSON in request body: #{e.message}"
+      end
+
+      def detect_format_from_content_type(content_type)
+        case content_type
+        when %r{application/json}
+          :json
+        when %r{application/x-www-form-urlencoded}, %r{multipart/form-data}
+          :form
+        else
+          :text
+        end
+      end
+
+      def serialize_validated_response(result, endpoint)
+        output, status_code = find_response_configuration(endpoint)
+
+        if output
+          build_validated_response(result, output, status_code)
+        else
+          build_default_response(result, status_code)
+        end
+      end
+
+      def find_response_configuration(endpoint)
+        output = find_response_output(endpoint)
+        status_code = find_status_code(endpoint)
+
+        [output, status_code]
+      end
+
+      def find_response_output(endpoint)
+        endpoint.outputs.find { |o| o.kind == :json } ||
+          endpoint.outputs.find { |o| o.kind == :text } ||
+          endpoint.outputs.first
+      end
+
+      def find_status_code(endpoint)
+        status_output = endpoint.outputs.find { |o| o.kind == :status }
+        status_output&.type || determine_default_status(endpoint.method)
+      end
+
+      def build_validated_response(result, output, status_code)
+        validate_response_result(result, output)
+
+        serialized = output.serialize(result)
+        content_type = determine_content_type(output)
+
+        [status_code, { 'Content-Type' => content_type }, [serialized]]
+      end
+
+      def validate_response_result(result, output)
+        validation_result = output.validate(result)
+        return if validation_result[:valid]
+
+        errors = validation_result[:errors].join(', ')
+        raise StandardError, "Response validation failed: #{errors}"
+      end
+
+      def build_default_response(result, status_code)
+        [status_code, { 'Content-Type' => 'application/json' }, [JSON.generate(result)]]
+      end
+
+      def determine_content_type(output)
+        case output.kind
+        when :text
+          'text/plain'
+        else # Default to JSON for :json and unknown formats
+          'application/json'
+        end
+      end
+
+      def determine_default_status(method)
+        case method
+        when :post
+          201
+        when :delete
+          204
+        else
+          200
+        end
+      end
+
+      def convert_to_enhanced(endpoint)
+        # Convert a regular endpoint to an enhanced endpoint
+        Core::EnhancedEndpoint.new(
+          method: endpoint.method,
+          path: endpoint.path,
+          inputs: endpoint.inputs,
+          outputs: endpoint.outputs,
+          errors: endpoint.errors,
+          metadata: endpoint.metadata
+        )
+      end
+
+      def handle_custom_error(error)
+        handler = @error_handlers[error.class] || @error_handlers[StandardError]
+        return nil unless handler
+
+        begin
+          result = handler.call(error)
+          [500, { 'Content-Type' => 'application/json' }, [JSON.generate(result)]]
+        rescue StandardError
+          # If custom error handler fails, fall back to default
+          nil
+        end
+      end
+
+      # Error response helpers
+      def not_found_response
+        error_data = {
+          error: 'Not Found',
+          message: 'The requested endpoint was not found',
+          code: 404
+        }
+        [404, { 'Content-Type' => 'application/json' }, [JSON.generate(error_data)]]
+      end
+
+      def validation_error_response(error)
+        error_data = {
+          error: 'Validation Error',
+          message: error.message,
+          code: 400
+        }
+        [400, { 'Content-Type' => 'application/json' }, [JSON.generate(error_data)]]
+      end
+
+      def type_validation_error_response(error)
+        error_data = {
+          error: 'Type Validation Error',
+          message: error.message,
+          type: error.type.to_s,
+          value: error.value,
+          errors: error.errors,
+          code: 400
+        }
+        [400, { 'Content-Type' => 'application/json' }, [JSON.generate(error_data)]]
+      end
+
+      def coercion_error_response(error)
+        error_data = {
+          error: 'Type Coercion Error',
+          message: error.message,
+          type: error.type.to_s,
+          value: error.value,
+          reason: error.reason,
+          code: 400
+        }
+        [400, { 'Content-Type' => 'application/json' }, [JSON.generate(error_data)]]
+      end
+
+      def error_response(error)
+        error_data = {
+          error: error.class.name,
+          message: error.message,
+          code: 500
+        }
+
+        [500, { 'Content-Type' => 'application/json' }, [JSON.generate(error_data)]]
+      end
+    end
+  end
+end

data/lib/rapitapir/server/middleware.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module RapiTapir
+  module Server
+    module Middleware
+      # Base middleware class for RapiTapir middleware
+      class Base
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          @app.call(env)
+        end
+      end
+
+      # Logging middleware for request/response logging
+      class Logger < Base
+        def initialize(app, logger = nil)
+          super(app)
+          @logger = logger || default_logger
+        end
+
+        def call(env)
+          start_time = Time.now
+          request = Rack::Request.new(env)
+
+          @logger.info("Started #{request.request_method} #{request.fullpath}")
+
+          status, headers, body = @app.call(env)
+
+          duration = ((Time.now - start_time) * 1000).round(2)
+          @logger.info("Completed #{status} in #{duration}ms")
+
+          [status, headers, body]
+        end
+
+        private
+
+        def default_logger
+          require 'logger'
+          Logger.new($stdout).tap do |logger|
+            logger.level = Logger::INFO
+            logger.formatter = proc do |severity, datetime, _progname, msg|
+              "[#{datetime.strftime('%Y-%m-%d %H:%M:%S')}] #{severity}: #{msg}\n"
+            end
+          end
+        end
+      end
+
+      # CORS middleware for cross-origin requests
+      class CORS < Base
+        def initialize(app, options = {})
+          super(app)
+          @options = {
+            allow_origin: '*',
+            allow_methods: %w[GET POST PUT DELETE OPTIONS PATCH],
+            allow_headers: %w[Content-Type Authorization],
+            max_age: 86_400
+          }.merge(options)
+        end
+
+        def call(env)
+          if env['REQUEST_METHOD'] == 'OPTIONS'
+            # Preflight request
+            [200, cors_headers, ['']]
+          else
+            status, headers, body = @app.call(env)
+            [status, headers.merge(cors_headers), body]
+          end
+        end
+
+        private
+
+        def cors_headers
+          {
+            'Access-Control-Allow-Origin' => @options[:allow_origin],
+            'Access-Control-Allow-Methods' => @options[:allow_methods].join(', '),
+            'Access-Control-Allow-Headers' => @options[:allow_headers].join(', '),
+            'Access-Control-Max-Age' => @options[:max_age].to_s
+          }
+        end
+      end
+
+      # Exception handling middleware
+      class ExceptionHandler < Base
+        def initialize(app, options = {})
+          super(app)
+          @show_exceptions = options.fetch(:show_exceptions, false)
+          @logger = options[:logger]
+        end
+
+        def call(env)
+          @app.call(env)
+        rescue StandardError => e
+          @logger&.error("Unhandled exception: #{e.class}: #{e.message}")
+          @logger&.error(e.backtrace.join("\n")) if @show_exceptions
+
+          error_response(e)
+        end
+
+        private
+
+        def error_response(error)
+          error_data = { error: 'Internal Server Error' }
+
+          if @show_exceptions
+            error_data.merge!(
+              exception: error.class.name,
+              message: error.message,
+              backtrace: error.backtrace
+            )
+          end
+
+          [500, { 'Content-Type' => 'application/json' }, [JSON.generate(error_data)]]
+        end
+      end
+    end
+  end
+end

data/lib/rapitapir/server/path_matcher.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RapiTapir
+  module Server
+    # Path matching utility for HTTP routes
+    # Matches request paths against endpoint path patterns with parameter extraction
+    class PathMatcher
+      attr_reader :path_pattern, :param_names
+
+      def initialize(path_pattern)
+        @path_pattern = path_pattern
+        @param_names = extract_param_names(path_pattern)
+        @regex = build_regex(path_pattern)
+      end
+
+      def match(path)
+        match_data = @regex.match(path)
+        return nil unless match_data
+
+        params = {}
+        @param_names.each_with_index do |param_name, index|
+          params[param_name.to_sym] = match_data[index + 1]
+        end
+
+        params
+      end
+
+      def matches?(path)
+        @regex.match?(path)
+      end
+
+      private
+
+      def extract_param_names(pattern)
+        pattern.scan(/:(\w+)/).flatten
+      end
+
+      def build_regex(pattern)
+        # Convert "/users/:id/posts/:post_id" to /^\/users\/([^\/]+)\/posts\/([^\/]+)$/
+        regex_pattern = pattern.gsub(/:(\w+)/, '([^/]+)')
+        Regexp.new("^#{regex_pattern}$")
+      end
+    end
+  end
+end