rapitapir 0.1.1 → 2.0.0

data/examples/rails/README.md

@@ -0,0 +1,497 @@
+# Using RapiTapir in Real Rails Applications
+
+This guide demonstrates how to integrate RapiTapir into real-world Rails 8+ applications for type-safe, documented APIs.
+
+## 🚀 Quick Start
+
+### 1. Add RapiTapir to your Gemfile
+
+```ruby
+gem 'rapitapir', '~> 1.0'
+```
+
+### 2. Update your ApplicationController
+
+```ruby
+class ApplicationController < RapiTapir::Server::Rails::ControllerBase
+  rapitapir do
+    development_defaults! if Rails.env.development?
+    
+    # Global error responses
+    error_out(json_body(error: T.string), 401)
+    error_out(json_body(error: T.string), 403) 
+    error_out(json_body(error: T.string), 404)
+    error_out(json_body(error: T.string, errors: T.array(T.string).optional), 422)
+  end
+end
+```
+
+### 3. Create API Controllers
+
+```ruby
+class Api::V1::UsersController < ApplicationController
+  rapitapir do
+    user_type = T.hash(
+      id: T.integer,
+      name: T.string,
+      email: T.string,
+      created_at: T.string
+    )
+    
+    GET('/api/v1/users')
+      .in(query(:page, T.integer.default(1)))
+      .out(json_body(users: T.array(user_type)))
+      .summary("List users")
+      .tag("Users")
+    
+    POST('/api/v1/users')
+      .in(json_body(name: T.string, email: T.string))
+      .out(json_body(user: user_type), 201)
+      .summary("Create user")
+      .tag("Users")
+  end
+  
+  def list_users
+    users = User.page(inputs[:page])
+    { users: users.map(&method(:serialize_user)) }
+  end
+  
+  def create_user
+    user = User.create!(inputs.slice(:name, :email))
+    render json: { user: serialize_user(user) }, status: 201
+  end
+  
+  private
+  
+  def serialize_user(user)
+    {
+      id: user.id,
+      name: user.name,
+      email: user.email,
+      created_at: user.created_at.iso8601
+    }
+  end
+end
+```
+
+### 4. Update Routes
+
+```ruby
+Rails.application.routes.draw do
+  namespace :api do
+    namespace :v1 do
+      rapitapir_routes_for 'Api::V1::UsersController'
+    end
+  end
+  
+  # Documentation (development only)
+  if Rails.env.development?
+    get '/docs', to: 'documentation#swagger_ui'
+    get '/openapi.json', to: 'documentation#openapi_spec'
+  end
+end
+```
+
+Use the new `ControllerBase` class for the cleanest syntax:
+
+```ruby
+# app/controllers/users_controller.rb
+require 'rapitapir/server/rails/controller_base'
+
+class UsersController < RapiTapir::Server::Rails::ControllerBase
+  rapitapir do
+    info(title: 'Users API', version: '1.0.0')
+    # development_defaults! # Coming soon
+  end
+
+  USER_SCHEMA = T.hash({
+    "id" => T.integer,
+    "name" => T.string,
+    "email" => T.email
+  })
+
+  api_resource '/users', schema: USER_SCHEMA do
+    crud do
+      index { User.all.map(&:attributes) }
+      show { |inputs| User.find(inputs[:id]).attributes }
+      create { |inputs| User.create!(inputs[:body]).attributes }
+    end
+  end
+end
+```
+
+### 3. Auto-Generate Routes
+
+Add to your `config/routes.rb`:
+
+```ruby
+Rails.application.routes.draw do
+  # Option 1: Auto-generate routes for specific controller
+  rapitapir_routes_for UsersController
+  
+  # Option 2: Auto-discover all RapiTapir controllers
+  rapitapir_auto_routes
+end
+```
+
+### 4. Access Documentation
+
+Start your Rails server and visit:
+- Interactive Documentation: `http://localhost:3000/docs`
+- OpenAPI Specification: `http://localhost:3000/openapi.json`
+
+## 🏗️ Core Features
+
+### Clean Base Class Syntax
+
+The new `ControllerBase` provides inheritance-based setup:
+
+```ruby
+class ApiController < RapiTapir::Server::Rails::ControllerBase
+  rapitapir do
+    info(title: 'My API', version: '1.0.0')
+  end
+
+  # T shortcut automatically available
+  # Enhanced HTTP verb DSL automatically available
+  # Auto action generation
+end
+```
+
+### Enhanced HTTP Verb DSL
+
+Use the same fluent DSL as Sinatra:
+
+```ruby
+endpoint(
+  GET('/books/:id')
+    .summary('Get book by ID')
+    .path_param(:id, T.integer(minimum: 1))
+    .ok(BOOK_SCHEMA)
+    .not_found(T.hash({ "error" => T.string }))
+    .build
+) do |inputs|
+  book = Book.find(inputs[:id])
+  book ? book.attributes : (render json: {error: 'Not found'}, status: 404)
+end
+```
+
+### RESTful Resource Builder
+
+Create complete CRUD APIs with minimal code:
+
+```ruby
+api_resource '/books', schema: BOOK_SCHEMA do
+  crud do
+    index do
+      books = Book.all
+      books = books.where(published: true) if params[:published] == 'true'
+      books.limit(params[:limit] || 50).map(&:attributes)
+    end
+    
+    show { |inputs| Book.find(inputs[:id]).attributes }
+    
+    create do |inputs|
+      book = Book.create!(inputs[:body])
+      response.status = 201
+      book.attributes
+    end
+    
+    update { |inputs| Book.update!(inputs[:id], inputs[:body]).attributes }
+    destroy { |inputs| Book.destroy(inputs[:id]); head :no_content }
+  end
+  
+  # Add custom endpoints
+  custom :get, 'featured' do
+    Book.where(featured: true).map(&:attributes)
+  end
+end
+```
+
+### Automatic Route Generation
+
+Three options for route generation:
+
+#### Option 1: Per-Controller Generation
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  rapitapir_routes_for UsersController
+  rapitapir_routes_for BooksController
+end
+```
+
+#### Option 2: Auto-Discovery
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  rapitapir_auto_routes  # Finds all RapiTapir controllers
+end
+```
+
+#### Option 3: Manual Routes (Still Supported)
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  resources :users, only: [:index, :show, :create, :update, :destroy]
+end
+```
+
+## 📋 Migration from Legacy Approach
+
+### Before (Verbose)
+
+```ruby
+class UsersController < ApplicationController
+  include RapiTapir::Server::Rails::Controller
+
+  rapitapir_endpoint :index, RapiTapir.get('/users')
+                                      .summary('List all users')
+                                      .out(RapiTapir::Core::Output.new(
+                                             kind: :json, type: { users: Array }
+                                           )) do |_inputs|
+    { users: @users.values }
+  end
+
+  def index
+    process_rapitapir_endpoint
+  end
+end
+```
+
+### After (Clean)
+
+```ruby
+class UsersController < RapiTapir::Server::Rails::ControllerBase
+  rapitapir do
+    info(title: 'Users API', version: '1.0.0')
+  end
+
+  USER_SCHEMA = T.hash({ "id" => T.integer, "name" => T.string })
+
+  api_resource '/users', schema: USER_SCHEMA do
+    crud do
+      index { User.all.map(&:attributes) }
+    end
+  end
+end
+```
+
+## 🔧 Advanced Features
+
+### Custom Endpoints with Full Type Safety
+
+```ruby
+endpoint(
+  POST('/users/bulk')
+    .summary('Create multiple users')
+    .json_body(T.array(USER_CREATE_SCHEMA))
+    .created(T.array(USER_SCHEMA))
+    .bad_request(ERROR_SCHEMA)
+    .build
+) do |inputs|
+  users = inputs[:body].map { |user_data| User.create!(user_data) }
+  response.status = 201
+  users.map(&:attributes)
+end
+```
+
+### Search Endpoints
+
+```ruby
+endpoint(
+  GET('/users/search')
+    .summary('Search users')
+    .query(:q, T.string(min_length: 1))
+    .query(:limit, T.optional(T.integer(minimum: 1, maximum: 100)))
+    .ok(T.array(USER_SCHEMA))
+    .build
+) do |inputs|
+  results = User.where("name ILIKE ?", "%#{inputs[:q]}%")
+  results = results.limit(inputs[:limit]) if inputs[:limit]
+  results.map(&:attributes)
+end
+```
+
+### Error Handling
+
+```ruby
+show do |inputs|
+  user = User.find_by(id: inputs[:id])
+  
+  if user.nil?
+    render json: { error: 'User not found' }, status: :not_found
+    return
+  end
+  
+  user.attributes
+end
+```
+
+## 📖 Complete Example
+
+Here's a full-featured Rails controller using all the enhanced features:
+
+```ruby
+# app/controllers/books_controller.rb
+require 'rapitapir/server/rails/controller_base'
+
+class BooksController < RapiTapir::Server::Rails::ControllerBase
+  rapitapir do
+    info(
+      title: 'Books API',
+      description: 'A comprehensive book management API',
+      version: '1.0.0'
+    )
+  end
+
+  BOOK_SCHEMA = T.hash({
+    "id" => T.integer,
+    "title" => T.string(min_length: 1, max_length: 255),
+    "author" => T.string(min_length: 1),
+    "published" => T.boolean,
+    "isbn" => T.optional(T.string),
+    "pages" => T.optional(T.integer(minimum: 1)),
+    "created_at" => T.datetime,
+    "updated_at" => T.datetime
+  })
+
+  BOOK_CREATE_SCHEMA = T.hash({
+    "title" => T.string(min_length: 1, max_length: 255),
+    "author" => T.string(min_length: 1),
+    "published" => T.optional(T.boolean),
+    "isbn" => T.optional(T.string),
+    "pages" => T.optional(T.integer(minimum: 1))
+  })
+
+  # CRUD operations with enhanced resource builder
+  api_resource '/books', schema: BOOK_SCHEMA do
+    crud do
+      index do
+        books = Book.includes(:author)
+        books = books.where(published: true) if params[:published] == 'true'
+        books = books.where('title ILIKE ?', "%#{params[:search]}%") if params[:search]
+        
+        limit = params[:limit]&.to_i || 20
+        offset = params[:offset]&.to_i || 0
+        
+        books.offset(offset).limit(limit).map(&:attributes)
+      end
+      
+      show do |inputs|
+        book = Book.find_by(id: inputs[:id])
+        book ? book.attributes : (render json: {error: 'Book not found'}, status: 404)
+      end
+      
+      create do |inputs|
+        book = Book.create!(inputs[:body])
+        response.status = 201
+        book.attributes
+      end
+      
+      update do |inputs|
+        book = Book.find_by(id: inputs[:id])
+        
+        if book.nil?
+          render json: { error: 'Book not found' }, status: 404
+          return
+        end
+        
+        book.update!(inputs[:body])
+        book.attributes
+      end
+      
+      destroy do |inputs|
+        book = Book.find_by(id: inputs[:id])
+        
+        if book.nil?
+          render json: { error: 'Book not found' }, status: 404
+          return
+        end
+        
+        book.destroy!
+        head :no_content
+      end
+    end
+    
+    # Custom endpoints
+    custom :get, 'featured' do
+      Book.where(featured: true).map(&:attributes)
+    end
+  end
+
+  # Additional custom endpoints
+  endpoint(
+    GET('/books/search')
+      .summary('Advanced book search')
+      .query(:q, T.string(min_length: 1), description: 'Search query')
+      .query(:author, T.optional(T.string), description: 'Filter by author')
+      .query(:published, T.optional(T.boolean), description: 'Filter by published status')
+      .query(:limit, T.optional(T.integer(minimum: 1, maximum: 100)), description: 'Results limit')
+      .ok(T.array(BOOK_SCHEMA))
+      .build
+  ) do |inputs|
+    query = inputs[:q]
+    books = Book.where('title ILIKE ? OR description ILIKE ?', "%#{query}%", "%#{query}%")
+    books = books.joins(:author).where('authors.name ILIKE ?', "%#{inputs[:author]}%") if inputs[:author]
+    books = books.where(published: inputs[:published]) if inputs.key?(:published)
+    books = books.limit(inputs[:limit] || 20)
+    
+    books.map(&:attributes)
+  end
+end
+```
+
+## 🛣️ Routes Configuration
+
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  # Auto-generate all RapiTapir routes
+  rapitapir_auto_routes
+  
+  # Or generate for specific controllers
+  # rapitapir_routes_for BooksController
+  # rapitapir_routes_for UsersController
+end
+```
+
+## 🎯 Benefits
+
+### Compared to Legacy Rails Integration
+
+| Feature | Legacy Approach | Enhanced Approach |
+|---------|----------------|-------------------|
+| **Base Class** | Manual include | Clean inheritance |
+| **HTTP Verbs** | Verbose `RapiTapir.get()` | Clean `GET()` |
+| **Type Shortcuts** | `RapiTapir::Types.string` | `T.string` |
+| **Action Generation** | Manual `def action; process_rapitapir_endpoint; end` | Automatic |
+| **Route Generation** | Manual Rails routes | Auto-generated |
+| **CRUD Operations** | Individual endpoint definitions | `api_resource` with `crud` block |
+| **Configuration** | Scattered setup | Single `rapitapir` block |
+
+### Compared to Sinatra
+
+| Feature | Sinatra | Enhanced Rails | Status |
+|---------|---------|----------------|---------|
+| **Clean Inheritance** | ✅ `< SinatraRapiTapir` | ✅ `< ControllerBase` | **Achieved** |
+| **HTTP Verb DSL** | ✅ `GET()`, `POST()` | ✅ `GET()`, `POST()` | **Achieved** |
+| **Resource Builder** | ✅ `api_resource` | ✅ `api_resource` | **Achieved** |
+| **T Shortcuts** | ✅ `T.string` | ✅ `T.string` | **Achieved** |
+| **Auto Routes** | ✅ Automatic | ✅ `rapitapir_auto_routes` | **Achieved** |
+| **Documentation** | ✅ `/docs` | 🚧 Coming soon | **In Progress** |
+
+## 🚧 Coming Soon
+
+- **Development Defaults**: Auto CORS, health checks, documentation
+- **Built-in Documentation**: `/docs` endpoint for Rails apps  
+- **Authentication Helpers**: Bearer token, OAuth2 integration
+- **Observability**: Metrics and tracing integration
+- **Generator**: Rails generator for RapiTapir controllers
+
+## 📚 See Also
+
+- [Enhanced Users Controller Example](enhanced_users_controller.rb)
+- [Legacy Users Controller Example](users_controller.rb) (for comparison)
+- [Sinatra Integration Guide](../docs/SINATRA_EXTENSION.md)
+- [Type System Documentation](../docs/types.md)

data/examples/rails/comprehensive_test.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Comprehensive Rails Integration Validation
+
+puts "🎯 RapiTapir Rails Integration - Comprehensive Test"
+puts "=" * 55
+
+success_count = 0
+total_tests = 7
+
+def test(description)
+  print "\n#{description}... "
+  begin
+    result = yield
+    puts "✅"
+    return true
+  rescue => e
+    puts "❌ #{e.message}"
+    return false
+  end
+end
+
+# Test 1: Basic loading
+success_count += 1 if test("Loading Rails integration") do
+  require_relative 'hello_world_app'
+  true
+end
+
+# Test 2: Controller inheritance  
+success_count += 1 if test("Controller inheritance working") do
+  HelloWorldController < RapiTapir::Server::Rails::ControllerBase
+end
+
+# Test 3: T shortcuts
+success_count += 1 if test("T shortcuts available") do
+  type = HelloWorldController::T.string
+  type.is_a?(RapiTapir::Types::String)
+end
+
+# Test 4: HTTP verbs
+success_count += 1 if test("HTTP verb DSL working") do
+  builder = HelloWorldController.GET('/test')
+  builder.is_a?(RapiTapir::DSL::FluentEndpointBuilder)
+end
+
+# Test 5: Endpoints registered
+success_count += 1 if test("Endpoints properly registered") do
+  endpoints = HelloWorldController.rapitapir_endpoints
+  endpoints.is_a?(Hash) && endpoints.count == 4
+end
+
+# Test 6: Rails routes generated
+success_count += 1 if test("Rails routes generated") do
+  routes = HelloWorldRailsApp.routes.routes
+  rapitapir_routes = routes.select { |r| r.defaults[:controller] == 'hello_world' }
+  rapitapir_routes.count == 4
+end
+
+# Test 7: Controller can be instantiated
+success_count += 1 if test("Controller instantiation") do
+  controller = HelloWorldController.new
+  controller.respond_to?(:process_rapitapir_endpoint)
+end
+
+puts "\n" + "=" * 55
+puts "🎉 Test Results: #{success_count}/#{total_tests} tests passed"
+
+if success_count == total_tests
+  puts "\n✅ RAILS INTEGRATION FULLY WORKING!"
+  puts "\n🚀 Key Features Implemented:"
+  puts "   • Enhanced controller base class"
+  puts "   • Sinatra-like syntax for Rails"
+  puts "   • Automatic action derivation"
+  puts "   • Route generation"
+  puts "   • Type shortcuts (T.string, etc.)"
+  puts "   • HTTP verb DSL"
+  puts "\n📋 Available Endpoints:"
+  HelloWorldController.rapitapir_endpoints.each do |action, config|
+    endpoint = config[:endpoint]
+    puts "   #{endpoint.method.upcase} #{endpoint.path} => #{action}"
+  end
+  
+  puts "\n🎯 Developer Experience Gap: ELIMINATED ✅"
+  puts "📊 Feature Parity with Sinatra: ACHIEVED ✅"
+  puts "\n🌟 Rails developers now have the same elegant syntax!"
+else
+  puts "\n❌ Some tests failed. Rails integration needs debugging."
+end
+
+puts "\n" + "=" * 55

data/examples/rails/config/routes.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Example Rails routes configuration for RapiTapir controllers
+# Place this in your config/routes.rb file
+
+Rails.application.routes.draw do
+  # Option 1: Auto-discover and register all RapiTapir controllers (Recommended)
+  # This will automatically find any controller that inherits from ControllerBase
+  # or includes the Rails::Controller module
+  rapitapir_auto_routes
+
+  # Option 2: Register specific controllers manually
+  # rapitapir_routes_for EnhancedUsersController
+  # rapitapir_routes_for BooksController
+  # rapitapir_routes_for OrdersController
+
+  # Option 3: Traditional Rails routes (still works if you prefer manual control)
+  # resources :enhanced_users, only: [:index, :show, :create, :update, :destroy] do
+  #   collection do
+  #     get :active
+  #     post :bulk
+  #     get :search
+  #   end
+  # end
+
+  # Example of mixed approach - some auto, some manual
+  # rapitapir_routes_for EnhancedUsersController
+  # 
+  # resources :admin_users, controller: 'admin/users' do
+  #   # Manual routes for admin section
+  # end
+
+  # The rapitapir_auto_routes method will generate routes like:
+  # 
+  # For EnhancedUsersController with api_resource '/users':
+  # GET    /users           enhanced_users#index
+  # GET    /users/:id       enhanced_users#show  
+  # POST   /users           enhanced_users#create
+  # PUT    /users/:id       enhanced_users#update
+  # DELETE /users/:id       enhanced_users#destroy
+  # GET    /users/active    enhanced_users#active
+  # POST   /users/bulk      enhanced_users#bulk
+  # GET    /users/search    enhanced_users#search
+  
+  # For documentation and OpenAPI endpoints (coming soon):
+  # GET    /docs            rapitapir#docs
+  # GET    /openapi.json    rapitapir#openapi
+end

data/examples/rails/debug_controller.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Debug Rails controller methods
+
+puts "🔍 Debugging Rails Controller Methods..."
+puts "=" * 45
+
+begin
+  # Load the controller
+  require_relative 'hello_world_app'
+  
+  puts "\n1️⃣ Checking controller class hierarchy..."
+  puts "HelloWorldController ancestors:"
+  HelloWorldController.ancestors[0..10].each_with_index do |ancestor, i|
+    puts "  #{i}: #{ancestor}"
+  end
+  
+  puts "\n2️⃣ Checking if controller includes required modules..."
+  includes_controller = HelloWorldController.included_modules.include?(RapiTapir::Server::Rails::Controller)
+  puts "Includes RapiTapir::Server::Rails::Controller: #{includes_controller}"
+  
+  includes_input_processor = HelloWorldController.included_modules.include?(RapiTapir::Server::Rails::InputProcessor)
+  puts "Includes InputProcessor: #{includes_input_processor}"
+  
+  includes_response_handler = HelloWorldController.included_modules.include?(RapiTapir::Server::Rails::ResponseHandler)
+  puts "Includes ResponseHandler: #{includes_response_handler}"
+  
+  puts "\n3️⃣ Checking available instance methods..."
+  controller = HelloWorldController.new
+  has_process_method = controller.respond_to?(:process_rapitapir_endpoint, true)
+  puts "Has process_rapitapir_endpoint method: #{has_process_method}"
+  
+  has_extract_inputs = controller.respond_to?(:extract_rails_inputs, true)
+  puts "Has extract_rails_inputs method: #{has_extract_inputs}"
+  
+  has_render_response = controller.respond_to?(:render_rapitapir_response, true)
+  puts "Has render_rapitapir_response method: #{has_render_response}"
+  
+  puts "\n4️⃣ Checking registered endpoints..."
+  endpoints = HelloWorldController.rapitapir_endpoints
+  puts "Registered endpoints: #{endpoints.keys}"
+  
+  endpoints.each do |action, config|
+    puts "  #{action}: #{config[:endpoint].method} #{config[:endpoint].path}"
+  end
+  
+  puts "\n5️⃣ Checking Rails controller methods..."
+  has_render = controller.respond_to?(:render)
+  puts "Has render method: #{has_render}"
+  
+  has_request = controller.respond_to?(:request)
+  puts "Has request method: #{has_request}"
+  
+  has_params = controller.respond_to?(:params)
+  puts "Has params method: #{has_params}"
+  
+  puts "\n✅ Debug complete!"
+  
+rescue => e
+  puts "❌ Error: #{e.message}"
+  puts e.backtrace[0..5].join("\n")
+end