rapitapir 0.1.0

data/lib/rapitapir/server/rack_adapter.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require 'rack'
+require 'json'
+require_relative '../core/endpoint'
+require_relative 'path_matcher'
+
+module RapiTapir
+  module Server
+    # Rack adapter for RapiTapir endpoints
+    # Integrates RapiTapir with Rack-based applications and frameworks
+    class RackAdapter
+      attr_reader :endpoints, :middleware_stack
+
+      def initialize
+        @endpoints = []
+        @middleware_stack = []
+      end
+
+      # Register an endpoint with the adapter
+      def register_endpoint(endpoint, handler)
+        unless endpoint.is_a?(RapiTapir::Core::Endpoint)
+          raise ArgumentError, 'Endpoint must be a RapiTapir::Core::Endpoint'
+        end
+        raise ArgumentError, 'Handler must respond to call' unless handler.respond_to?(:call)
+
+        endpoint.validate!
+        path_matcher = PathMatcher.new(endpoint.path)
+        @endpoints << { endpoint: 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
+
+      # 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 (without middleware)
+      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
+          process_request(request, endpoint_match)
+        rescue StandardError => 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_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
+        processed_inputs = extract_inputs(request, endpoint, path_params)
+
+        # Call the handler with processed inputs
+        result = handler.call(processed_inputs)
+
+        # Serialize and return response
+        serialize_response(result, endpoint)
+      end
+
+      def extract_inputs(request, endpoint, path_params = {})
+        inputs = {}
+
+        endpoint.inputs.each do |input|
+          value = extract_input_value(request, input, path_params)
+          process_input_value(inputs, input, value)
+        end
+
+        inputs
+      end
+
+      def extract_input_value(request, input, path_params)
+        case input.kind
+        when :query
+          request.params[input.name.to_s]
+        when :header
+          request.get_header("HTTP_#{input.name.to_s.upcase}")
+        when :path
+          path_params[input.name]
+        when :body
+          parse_body(request, input)
+        end
+      end
+
+      def process_input_value(inputs, input, value)
+        validate_required_input(input, value)
+        coerce_and_store_input(inputs, input, value)
+      end
+
+      def validate_required_input(input, value)
+        raise ArgumentError, "Required input '#{input.name}' is missing" if value.nil? && input.required?
+      end
+
+      def coerce_and_store_input(inputs, input, value)
+        if value.nil?
+          inputs[input.name] = nil unless input.required?
+        else
+          inputs[input.name] = input.coerce(value)
+        end
+      end
+
+      def parse_body(request, input)
+        body = request.body.read
+        request.body.rewind
+
+        return nil if body.empty?
+
+        if input.type == Hash || input.type.is_a?(Hash)
+          JSON.parse(body)
+        else
+          body
+        end
+      rescue JSON::ParserError
+        raise ArgumentError, 'Invalid JSON in request body'
+      end
+
+      def serialize_response(result, endpoint)
+        # Find the appropriate output definition
+        output = endpoint.outputs.find { |o| o.kind == :json } || endpoint.outputs.first
+
+        if output
+          serialized = output.serialize(result)
+          content_type = determine_content_type(output)
+          status_code = determine_status_code(endpoint)
+
+          [status_code, { 'Content-Type' => content_type }, [serialized]]
+        else
+          # Default response if no output defined
+          [200, { 'Content-Type' => 'text/plain' }, [result.to_s]]
+        end
+      end
+
+      def determine_content_type(output)
+        # For enhanced outputs, use the content_type attribute directly
+        return output.content_type if output.respond_to?(:content_type) && output.content_type
+
+        # Fallback to kind-based detection for legacy outputs
+        case output.kind
+        when :json
+          'application/json'
+        when :xml
+          'application/xml'
+        else
+          'text/plain'
+        end
+      end
+
+      def determine_status_code(endpoint)
+        status_output = endpoint.outputs.find { |o| o.kind == :status }
+        status_output ? status_output.type : 200
+      end
+
+      def not_found_response
+        [404, { 'Content-Type' => 'application/json' }, ['{"error":"Not Found"}']]
+      end
+
+      def error_response(error)
+        error_data = {
+          error: error.class.name,
+          message: error.message
+        }
+
+        status_code = case error
+                      when ArgumentError
+                        400
+                      else
+                        500
+                      end
+
+        [status_code, { 'Content-Type' => 'application/json' }, [JSON.generate(error_data)]]
+      end
+    end
+  end
+end

data/lib/rapitapir/server/rails_adapter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'rails_controller'
+require_relative 'rails_adapter_class'
+
+module RapiTapir
+  module Server
+    # Rails integration module for RapiTapir
+    #
+    # Provides controller concerns and adapters for seamless integration with Rails applications.
+    # Split into separate files for better organization while maintaining compatibility.
+    module Rails
+      # Main module that includes both Controller concern and RailsAdapter class
+      # This maintains backward compatibility while organizing code better
+    end
+  end
+end

data/lib/rapitapir/server/rails_adapter_class.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RapiTapir
+  module Server
+    module Rails
+      # Rails adapter for automatic route generation
+      class RailsAdapter
+        attr_reader :endpoints
+
+        def initialize
+          @endpoints = []
+        end
+
+        # Register an endpoint and generate Rails routes
+        def register_endpoint(endpoint, controller_class, action_name)
+          unless endpoint.is_a?(RapiTapir::Core::Endpoint)
+            raise ArgumentError, 'Endpoint must be a RapiTapir::Core::Endpoint'
+          end
+
+          endpoint.validate!
+
+          @endpoints << {
+            endpoint: endpoint,
+            controller: controller_class,
+            action: action_name
+          }
+        end
+
+        # Generate Rails routes for registered endpoints
+        def generate_routes(rails_routes)
+          @endpoints.each do |endpoint_config|
+            endpoint = endpoint_config[:endpoint]
+            controller = endpoint_config[:controller]
+            action = endpoint_config[:action]
+
+            method_name = endpoint.method.to_s.downcase
+            path_pattern = convert_path_to_rails(endpoint.path)
+            controller_name = controller.name.underscore.sub(/_controller$/, '')
+
+            rails_routes.send(method_name, path_pattern, to: "#{controller_name}##{action}")
+          end
+        end
+
+        private
+
+        def convert_path_to_rails(path)
+          # Convert "/users/:id" to "/users/:id" (Rails format is the same)
+          path
+        end
+      end
+    end
+  end
+end

data/lib/rapitapir/server/rails_controller.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative 'rails_input_processor'
+require_relative 'rails_response_handler'
+
+module RapiTapir
+  module Server
+    module Rails
+      # Rails controller concern for RapiTapir integration
+      module Controller
+        extend ActiveSupport::Concern
+        include InputProcessor
+        include ResponseHandler
+
+        included do
+          class_attribute :rapitapir_endpoints, default: {}
+        end
+
+        class_methods do
+          # Register an endpoint for this controller
+          def rapitapir_endpoint(action_name, endpoint, &handler)
+            unless endpoint.is_a?(RapiTapir::Core::Endpoint)
+              raise ArgumentError, 'Endpoint must be a RapiTapir::Core::Endpoint'
+            end
+
+            endpoint.validate!
+
+            self.rapitapir_endpoints = rapitapir_endpoints.merge(
+              action_name.to_sym => {
+                endpoint: endpoint,
+                handler: handler
+              }
+            )
+          end
+        end
+
+        private
+
+        # Process a RapiTapir endpoint within a Rails action
+        def process_rapitapir_endpoint(action_name = nil)
+          action_name ||= params[:action]&.to_sym || :index
+          endpoint_config = find_endpoint_config(action_name)
+
+          return render_endpoint_not_configured_error unless endpoint_config
+
+          process_configured_endpoint(endpoint_config)
+        end
+
+        def find_endpoint_config(action_name)
+          self.class.rapitapir_endpoints[action_name.to_sym]
+        end
+
+        def render_endpoint_not_configured_error
+          render json: { error: 'Endpoint not configured' }, status: 500
+        end
+
+        def process_configured_endpoint(endpoint_config)
+          endpoint = endpoint_config[:endpoint]
+          handler = endpoint_config[:handler]
+
+          processed_inputs = extract_rails_inputs(endpoint, request)
+          result = instance_exec(processed_inputs, &handler)
+          render_rapitapir_response(result, endpoint)
+        rescue ArgumentError => e
+          render json: { error: e.message }, status: 400
+        rescue StandardError => e
+          render json: { error: 'Internal Server Error', message: e.message }, status: 500
+        end
+      end
+    end
+  end
+end

data/lib/rapitapir/server/rails_input_processor.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RapiTapir
+  module Server
+    module Rails
+      # Input processing methods for Rails controller integration
+      module InputProcessor
+        private
+
+        def extract_rails_inputs(endpoint, request)
+          inputs = {}
+
+          endpoint.inputs.each do |input|
+            value = extract_input_value(input, request)
+            validate_required_input(input, value)
+            add_input_to_collection(inputs, input, value)
+          end
+
+          inputs
+        end
+
+        def extract_input_value(input, request)
+          case input.kind
+          when :query
+            extract_query_value(request, input)
+          when :header
+            extract_header_value(request, input)
+          when :path
+            params[input.name.to_s]
+          when :body
+            parse_rails_body(request, input)
+          end
+        end
+
+        def extract_query_value(request, input)
+          request.query_parameters[input.name.to_s] || params[input.name.to_s]
+        end
+
+        def extract_header_value(request, input)
+          request.headers[input.name.to_s] || request.headers["HTTP_#{input.name.to_s.upcase}"]
+        end
+
+        def validate_required_input(input, value)
+          return unless value.nil? && input.required?
+
+          raise ArgumentError, "Required input '#{input.name}' is missing"
+        end
+
+        def add_input_to_collection(inputs, input, value)
+          return unless value || !input.required?
+
+          inputs[input.name] = input.coerce(value)
+        end
+
+        def parse_rails_body(request, input)
+          # Rails typically parses JSON automatically into params
+          if input.type == Hash || input.type.is_a?(Hash)
+            # Try to get from parsed params first
+            request.request_parameters.presence ||
+              # Fall back to parsing raw body
+              begin
+                JSON.parse(request.raw_post)
+              rescue JSON::ParserError
+                raise ArgumentError, 'Invalid JSON in request body'
+              end
+          else
+            request.raw_post
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rapitapir/server/rails_response_handler.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RapiTapir
+  module Server
+    module Rails
+      # Response handling methods for Rails controller integration
+      module ResponseHandler
+        private
+
+        def render_rapitapir_response(result, endpoint)
+          output = endpoint.outputs.find { |o| o.kind == :json } || endpoint.outputs.first
+          status_code = determine_rails_status_code(endpoint)
+
+          if output&.kind == :xml
+            render xml: result, status: status_code
+          else
+            # Default to JSON for nil output, :json kind, or unknown kinds
+            render json: result, status: status_code
+          end
+        end
+
+        def determine_rails_status_code(endpoint)
+          status_output = endpoint.outputs.find { |o| o.kind == :status }
+          status_output ? status_output.type : 200
+        end
+      end
+    end
+  end
+end

data/lib/rapitapir/server/sinatra_adapter.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module RapiTapir
+  module Server
+    # Sinatra integration adapter for RapiTapir
+    # Provides seamless integration with Sinatra applications
+    class SinatraAdapter
+      attr_reader :app, :endpoints
+
+      def initialize(sinatra_app)
+        @app = sinatra_app
+        @endpoints = []
+
+        # Store adapter reference in the app for access in route handlers
+        @app.instance_variable_set(:@rapitapir_adapter, self)
+
+        # Define a helper method on the app to access the adapter
+        @app.define_singleton_method(:rapitapir_adapter) do
+          @rapitapir_adapter
+        end
+      end
+
+      # Register an endpoint with automatic Sinatra route creation
+      def register_endpoint(endpoint, handler = nil, &block)
+        unless endpoint.is_a?(RapiTapir::Core::Endpoint)
+          raise ArgumentError, 'Endpoint must be a RapiTapir::Core::Endpoint'
+        end
+
+        endpoint.validate!
+
+        # Use provided handler or block
+        endpoint_handler = handler || block
+        raise ArgumentError, 'Handler must be provided' unless endpoint_handler
+
+        endpoint_info = { endpoint: endpoint, handler: endpoint_handler, id: @endpoints.length }
+        @endpoints << endpoint_info
+
+        # Register route with Sinatra
+        register_sinatra_route(endpoint_info)
+      end
+
+      private
+
+      # rubocop:disable Metrics/AbcSize
+      def register_sinatra_route(endpoint_info)
+        method_name = endpoint_info[:endpoint].method.to_s.downcase.to_sym
+        path_pattern = convert_path_to_sinatra(endpoint_info[:endpoint].path)
+        endpoint_id = endpoint_info[:id]
+        adapter = self
+
+        @app.send(method_name, path_pattern) do
+          result = adapter.handle_sinatra_request(endpoint_id, request, params)
+          if result.is_a?(Array) && result.length == 3
+            status result[0]
+            headers result[1]
+            body result[2]
+          else
+            result
+          end
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      public
+
+      def handle_sinatra_request(endpoint_id, request, params)
+        endpoint_data = @endpoints[endpoint_id]
+
+        begin
+          processed_inputs = extract_sinatra_inputs(request, params, endpoint_data[:endpoint])
+          result = @app.instance_exec(processed_inputs, &endpoint_data[:handler])
+          send_successful_response(endpoint_data, result)
+        rescue ArgumentError => e
+          error_response(400, e.message)
+        rescue StandardError => e
+          error_response(500, 'Internal Server Error', e.message)
+        end
+      end
+
+      def error_response(status_code, error, message = nil)
+        error_data = { error: error }
+        error_data[:message] = message if message
+        [status_code, { 'Content-Type' => 'application/json' }, [error_data.to_json]]
+      end
+
+      def execute_endpoint_handler(endpoint_data, processed_inputs)
+        case endpoint_data[:handler]
+        when Proc
+          instance_exec(processed_inputs, &endpoint_data[:handler])
+        else
+          call_handler_method(endpoint_data[:handler], processed_inputs)
+        end
+      end
+
+      def call_handler_method(handler, processed_inputs)
+        if handler.respond_to?(:call)
+          handler.call(processed_inputs)
+        else
+          instance_exec(processed_inputs, &handler)
+        end
+      end
+
+      def send_successful_response(endpoint_data, result)
+        endpoint = endpoint_data[:endpoint]
+
+        # Find status code from outputs
+        status_output = endpoint.outputs.find { |o| o.kind == :status }
+        status_code = status_output ? status_output.type : 200
+
+        # Default headers
+        headers = { 'Content-Type' => 'application/json' }
+
+        # Add any additional headers from outputs if they exist
+        # Note: This is for future compatibility when header outputs are supported
+
+        [status_code, headers, [result.to_json]]
+      end
+
+      def convert_path_to_sinatra(path)
+        # Convert "/users/:id" to "/users/:id" (Sinatra format is the same)
+        path
+      end
+
+      def extract_sinatra_inputs(request, params, endpoint)
+        inputs = {}
+
+        endpoint.inputs.each do |input|
+          value = extract_input_value(request, params, input)
+          validate_and_add_input(inputs, input, value)
+        end
+
+        inputs
+      end
+
+      private
+
+      def extract_input_value(request, params, input)
+        case input.kind
+        when :query, :path
+          # Both query and path parameters are available in params
+          params[input.name.to_s] || params[input.name.to_sym]
+        when :header
+          request.env["HTTP_#{input.name.to_s.upcase}"]
+        when :body
+          parse_sinatra_body(request, input)
+        end
+      end
+
+      def validate_and_add_input(inputs, input, value)
+        # Validate and coerce the value
+        raise ArgumentError, "Required input '#{input.name}' is missing" if value.nil? && input.required?
+
+        inputs[input.name] = input.coerce(value) if value || !input.required?
+      end
+
+      def parse_sinatra_body(request, input)
+        body = request.body.read
+        request.body.rewind
+
+        return nil if body.empty?
+
+        if input.type == Hash || input.type.is_a?(Hash)
+          JSON.parse(body)
+        else
+          body
+        end
+      rescue JSON::ParserError
+        raise ArgumentError, 'Invalid JSON in request body'
+      end
+
+      def serialize_response(result, endpoint)
+        output = endpoint.outputs.find { |o| o.kind == :json } || endpoint.outputs.first
+
+        if output
+          output.serialize(result)
+        else
+          result.to_json
+        end
+      end
+
+      def determine_content_type(endpoint)
+        output = endpoint.outputs.find { |o| o.kind == :json } || endpoint.outputs.first
+
+        case output&.kind
+        when :xml
+          'application/xml'
+        else # Default to JSON for :json and unknown formats
+          'application/json'
+        end
+      end
+
+      def determine_status_code(endpoint)
+        status_output = endpoint.outputs.find { |o| o.kind == :status }
+        status_output ? status_output.type : 200
+      end
+    end
+  end
+end