funapi 0.1.0

data/examples/dependency_injection_demo.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require_relative "../lib/funapi"
+require_relative "../lib/funapi/server/falcon"
+
+FAKE_DB = {
+  users: [
+    {id: 1, name: "Alice", email: "alice@example.com", role: "admin"},
+    {id: 2, name: "Bob", email: "bob@example.com", role: "user"},
+    {id: 3, name: "Charlie", email: "charlie@example.com", role: "user"}
+  ]
+}
+
+class Database
+  def self.connect
+    new
+  end
+
+  def find_user(id)
+    FAKE_DB[:users].find { |u| u[:id] == id.to_i }
+  end
+
+  def all_users
+    FAKE_DB[:users]
+  end
+
+  def create_user(attrs)
+    id = (FAKE_DB[:users].map { |u| u[:id] }.max || 0) + 1
+    user = attrs.merge(id: id)
+    FAKE_DB[:users] << user
+    user
+  end
+end
+
+def require_auth
+  lambda { |req:|
+    token = req.env["HTTP_AUTHORIZATION"]&.split(" ")&.last
+    raise FunApi::HTTPException.new(status_code: 401, detail: "Not authenticated") unless token
+
+    user_id = token.to_i
+    raise FunApi::HTTPException.new(status_code: 401, detail: "Invalid token") if user_id.zero?
+
+    user_id
+  }
+end
+
+def get_current_user
+  lambda { |db:, user_id: FunApi::Depends(require_auth)|
+    user = db.find_user(user_id)
+    raise FunApi::HTTPException.new(status_code: 404, detail: "User not found") unless user
+
+    user
+  }
+end
+
+def require_admin
+  lambda { |user: FunApi::Depends(get_current_user)|
+    raise FunApi::HTTPException.new(status_code: 403, detail: "Admin access required") unless user[:role] == "admin"
+
+    user
+  }
+end
+
+class Paginator
+  def initialize(max_limit: 100)
+    @max_limit = max_limit
+  end
+
+  def call(input:)
+    limit = (input[:query][:limit] || 10).to_i
+    offset = (input[:query][:offset] || 0).to_i
+
+    {
+      limit: [limit, @max_limit].min,
+      offset: [offset, 0].max
+    }
+  end
+end
+
+QuerySchema = FunApi::Schema.define do
+  optional(:limit).filled(:integer)
+  optional(:offset).filled(:integer)
+end
+
+UserCreateSchema = FunApi::Schema.define do
+  required(:name).filled(:string)
+  required(:email).filled(:string)
+  optional(:role).filled(:string)
+end
+
+app = FunApi::App.new(
+  title: "Dependency Injection Demo",
+  version: "1.0.0",
+  description: "Demonstrating FunApi dependency injection features"
+) do |api|
+  api.register(:db) { Database.connect }
+
+  api.register(:logger) do
+    logger = Logger.new($stdout)
+    logger.level = Logger::INFO
+    logger
+  end
+
+  api.get "/" do |_input, _req, _task|
+    [{
+      message: "Dependency Injection Demo API",
+      endpoints: {
+        public: "GET /",
+        users_list: "GET /users",
+        user_detail: "GET /users/:id",
+        profile: "GET /profile (requires auth)",
+        create_user: "POST /users (requires admin)",
+        admin: "GET /admin (requires admin)"
+      },
+      auth: "Use header: Authorization: Bearer <user_id>"
+    }, 200]
+  end
+
+  api.get "/users",
+    query: QuerySchema,
+    depends: {
+      db: nil,
+      page: Paginator.new(max_limit: 50)
+    } do |_input, _req, _task, db:, page:|
+    users = db.all_users[page[:offset], page[:limit]]
+
+    [{
+      users: users,
+      pagination: page,
+      total: FAKE_DB[:users].length
+    }, 200]
+  end
+
+  api.get "/users/:id",
+    depends: [:db] do |input, _req, _task, db:|
+    user = db.find_user(input[:path]["id"])
+    raise FunApi::HTTPException.new(status_code: 404, detail: "User not found") unless user
+
+    [user, 200]
+  end
+
+  api.get "/profile",
+    depends: {
+      user: get_current_user,
+      db: nil
+    } do |_input, _req, _task, user:, db:|
+    [user, 200]
+  end
+
+  api.post "/users",
+    body: UserCreateSchema,
+    depends: {
+      admin: require_admin,
+      db: nil,
+      logger: nil
+    } do |input, _req, _task, admin:, db:, logger:|
+    user_data = input[:body]
+    user_data[:role] ||= "user"
+
+    new_user = db.create_user(user_data)
+    logger.info("Admin #{admin[:name]} created user: #{new_user[:name]}")
+
+    [new_user, 201]
+  end
+
+  api.get "/admin",
+    depends: {admin: require_admin} do |_input, _req, _task, admin:|
+    [{
+      message: "Welcome to admin area",
+      admin: admin
+    }, 200]
+  end
+end
+
+puts "\n🚀 FunApi Dependency Injection Demo"
+puts "=" * 50
+puts "\nServer starting on http://localhost:3000"
+puts "\n📚 API Docs: http://localhost:3000/docs"
+puts "\n✨ Try these commands:\n"
+puts "\n# Public endpoint"
+puts "curl http://localhost:3000/"
+puts "\n# List users (with pagination)"
+puts "curl http://localhost:3000/users"
+puts "curl 'http://localhost:3000/users?limit=2&offset=0'"
+puts "\n# Get specific user"
+puts "curl http://localhost:3000/users/1"
+puts "\n# Get profile (requires auth)"
+puts "curl -H 'Authorization: Bearer 1' http://localhost:3000/profile"
+puts "curl -H 'Authorization: Bearer 2' http://localhost:3000/profile"
+puts "\n# Admin area (requires admin role)"
+puts "curl -H 'Authorization: Bearer 1' http://localhost:3000/admin"
+puts "curl -H 'Authorization: Bearer 2' http://localhost:3000/admin  # Should fail (403)"
+puts "\n# Create user (requires admin)"
+puts "curl -X POST http://localhost:3000/users \\"
+puts "  -H 'Authorization: Bearer 1' \\"
+puts "  -H 'Content-Type: application/json' \\"
+puts "  -d '{\"name\":\"Dave\",\"email\":\"dave@example.com\",\"role\":\"user\"}'"
+puts "\n" + ("=" * 50) + "\n\n"
+
+FunApi::Server::Falcon.start(app, port: 3000)

data/examples/lifecycle_demo.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../lib/funapi"
+require_relative "../lib/funapi/server/falcon"
+
+DB = {connected: false, users: []}
+CACHE = {warmed: false}
+
+app = FunApi::App.new(
+  title: "Lifecycle Demo",
+  version: "1.0.0"
+) do |api|
+  api.on_startup do
+    puts "Connecting to database..."
+    sleep 0.1
+    DB[:connected] = true
+    DB[:users] = [{id: 1, name: "Alice"}, {id: 2, name: "Bob"}]
+    puts "Database connected!"
+  end
+
+  api.on_startup do
+    puts "Warming cache..."
+    sleep 0.05
+    CACHE[:warmed] = true
+    puts "Cache warmed!"
+  end
+
+  api.on_shutdown do
+    puts "Closing database connection..."
+    DB[:connected] = false
+    puts "Database disconnected!"
+  end
+
+  api.on_shutdown do
+    puts "Clearing cache..."
+    CACHE[:warmed] = false
+    puts "Cache cleared!"
+  end
+
+  api.get "/status" do |_input, _req, _task|
+    [{
+      db_connected: DB[:connected],
+      cache_warmed: CACHE[:warmed]
+    }, 200]
+  end
+
+  api.get "/users" do |_input, _req, _task|
+    [DB[:users], 200]
+  end
+end
+
+puts "Starting Lifecycle Demo..."
+puts "Try: curl http://localhost:3000/status"
+puts "Try: curl http://localhost:3000/users"
+puts ""
+
+FunApi::Server::Falcon.start(app, port: 3000)

data/examples/middleware_demo.rb

@@ -0,0 +1,74 @@
+require_relative "../lib/funapi"
+require_relative "../lib/funapi/server/falcon"
+
+UserSchema = FunApi::Schema.define do
+  required(:name).filled(:string)
+  required(:email).filled(:string)
+end
+
+app = FunApi::App.new(
+  title: "Middleware Demo API",
+  version: "1.0.0",
+  description: "Demonstrating FunApi middleware capabilities"
+) do |api|
+  api.add_cors(
+    allow_origins: ["http://localhost:3000", "http://127.0.0.1:3000"],
+    allow_methods: %w[GET POST PUT DELETE],
+    allow_headers: %w[Content-Type Authorization]
+  )
+
+  api.add_request_logger
+
+  api.add_trusted_host(
+    allowed_hosts: ["localhost", "127.0.0.1", /\.example\.com$/]
+  )
+
+  api.get "/" do |_input, _req, _task|
+    [{message: "Welcome to FunApi Middleware Demo!"}, 200]
+  end
+
+  api.get "/health" do |_input, _req, _task|
+    [{status: "healthy", timestamp: Time.now.to_i}, 200]
+  end
+
+  api.post "/users", body: UserSchema do |input, _req, _task|
+    user = input[:body].merge(id: rand(1000), created_at: Time.now.to_i)
+    [user, 201]
+  end
+
+  api.get "/async-demo" do |_input, _req, task|
+    result1 = task.async do
+      sleep 0.1
+      {data: "from task 1"}
+    end
+    result2 = task.async do
+      sleep 0.1
+      {data: "from task 2"}
+    end
+
+    [{results: [result1.wait, result2.wait]}, 200]
+  end
+end
+
+puts "🚀 Middleware Demo Server"
+puts "=========================="
+puts ""
+puts "Enabled Middleware:"
+puts "  ✓ CORS (localhost:3000, 127.0.0.1:3000)"
+puts "  ✓ Request Logger"
+puts "  ✓ Trusted Host"
+puts ""
+puts "Endpoints:"
+puts "  GET  http://localhost:3000/"
+puts "  GET  http://localhost:3000/health"
+puts "  POST http://localhost:3000/users"
+puts "  GET  http://localhost:3000/async-demo"
+puts "  GET  http://localhost:3000/docs (Swagger UI)"
+puts ""
+puts "Try:"
+puts "  curl http://localhost:3000/"
+puts "  curl -X POST http://localhost:3000/users -H 'Content-Type: application/json' -d '{\"name\":\"John\",\"email\":\"john@example.com\"}'"
+puts "  curl http://localhost:3000/async-demo"
+puts ""
+
+FunApi::Server::Falcon.start(app, port: 3000)

data/examples/templates/layouts/application.html.erb

@@ -0,0 +1,66 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title><%= title %></title>
+  <script src="https://unpkg.com/htmx.org@2.0.4"></script>
+  <style>
+    * { box-sizing: border-box; }
+    body { 
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      max-width: 600px; 
+      margin: 40px auto; 
+      padding: 20px;
+      background: #f5f5f5;
+    }
+    h1 { color: #333; }
+    .todo-form { display: flex; gap: 10px; margin-bottom: 20px; }
+    .todo-form input { 
+      flex: 1; 
+      padding: 10px; 
+      border: 1px solid #ddd; 
+      border-radius: 4px;
+      font-size: 16px;
+    }
+    .todo-form button { 
+      padding: 10px 20px; 
+      background: #007bff; 
+      color: white; 
+      border: none; 
+      border-radius: 4px;
+      cursor: pointer;
+      font-size: 16px;
+    }
+    .todo-form button:hover { background: #0056b3; }
+    .todo-list { list-style: none; padding: 0; }
+    .todo-item { 
+      display: flex; 
+      align-items: center; 
+      gap: 10px;
+      padding: 15px; 
+      background: white; 
+      margin-bottom: 10px; 
+      border-radius: 4px;
+      box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+    }
+    .todo-item.completed span { text-decoration: line-through; color: #888; }
+    .todo-item span { flex: 1; }
+    .todo-item button { 
+      padding: 5px 10px; 
+      border: none; 
+      border-radius: 4px;
+      cursor: pointer;
+    }
+    .btn-toggle { background: #28a745; color: white; }
+    .btn-toggle:hover { background: #218838; }
+    .btn-delete { background: #dc3545; color: white; }
+    .btn-delete:hover { background: #c82333; }
+    .htmx-request { opacity: 0.5; }
+  </style>
+</head>
+<body>
+  <h1><%= title %></h1>
+  <%= yield_content %>
+</body>
+</html>

data/examples/templates/todos/_todo.html.erb

@@ -0,0 +1,15 @@
+<li id="todo-<%= todo[:id] %>" class="todo-item<%= " completed" if todo[:completed] %>">
+  <span><%= todo[:title] %></span>
+  <button class="btn-toggle"
+          hx-patch="/todos/<%= todo[:id] %>/toggle"
+          hx-target="#todo-<%= todo[:id] %>"
+          hx-swap="outerHTML">
+    <%= todo[:completed] ? "Undo" : "Done" %>
+  </button>
+  <button class="btn-delete"
+          hx-delete="/todos/<%= todo[:id] %>"
+          hx-target="#todo-<%= todo[:id] %>"
+          hx-swap="outerHTML">
+    Delete
+  </button>
+</li>

data/examples/templates/todos/index.html.erb

@@ -0,0 +1,12 @@
+<form class="todo-form" hx-post="/todos" hx-target="#todo-list" hx-swap="beforeend" hx-on::after-request="this.reset()">
+  <input type="text" name="title" placeholder="What needs to be done?" required>
+  <button type="submit">Add</button>
+</form>
+
+<ul id="todo-list" class="todo-list">
+<% todos.each do |todo| -%>
+<%= render_partial("todos/_todo.html.erb", todo: todo) %>
+<% end -%>
+</ul>
+
+<p><small>Powered by FunApi + HTMX</small></p>

data/examples/templates_demo.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "../lib/funapi"
+require_relative "../lib/fun_api/templates"
+require_relative "../lib/funapi/server/falcon"
+
+TODOS = [
+  {id: 1, title: "Learn FunApi", completed: true},
+  {id: 2, title: "Build something with HTMX", completed: false},
+  {id: 3, title: "Deploy to production", completed: false}
+]
+
+TodoSchema = FunApi::Schema.define do
+  required(:title).filled(:string)
+end
+
+templates = FunApi::Templates.new(
+  directory: File.join(__dir__, "templates"),
+  layout: "layouts/application.html.erb"
+)
+
+app = FunApi::App.new(
+  title: "HTMX Todo Demo",
+  version: "1.0.0",
+  description: "A simple todo app demonstrating FunApi templates with HTMX"
+) do |api|
+  api.get "/" do |_input, _req, _task|
+    templates.response("todos/index.html.erb",
+      title: "Todo List",
+      todos: TODOS)
+  end
+
+  api.post "/todos", body: TodoSchema do |input, _req, _task|
+    new_id = (TODOS.map { |t| t[:id] }.max || 0) + 1
+    todo = {
+      id: new_id,
+      title: input[:body][:title],
+      completed: false
+    }
+    TODOS << todo
+
+    templates.response("todos/_todo.html.erb",
+      layout: false,
+      todo: todo,
+      status: 201)
+  end
+
+  api.patch "/todos/:id/toggle" do |input, _req, _task|
+    todo_id = input[:path]["id"].to_i
+    todo = TODOS.find { |t| t[:id] == todo_id }
+
+    unless todo
+      raise FunApi::HTTPException.new(status_code: 404, detail: "Todo not found")
+    end
+
+    todo[:completed] = !todo[:completed]
+
+    templates.response("todos/_todo.html.erb",
+      layout: false,
+      todo: todo)
+  end
+
+  api.delete "/todos/:id" do |input, _req, _task|
+    todo_id = input[:path]["id"].to_i
+    TODOS.reject! { |t| t[:id] == todo_id }
+
+    FunApi::TemplateResponse.new("")
+  end
+
+  api.get "/api/todos" do |_input, _req, _task|
+    [TODOS, 200]
+  end
+end
+
+puts "Starting HTMX Todo Demo..."
+puts "Open http://localhost:3000 in your browser"
+puts ""
+puts "Features:"
+puts "  - Add todos with the form"
+puts "  - Toggle completion with 'Done' button"
+puts "  - Delete todos with 'Delete' button"
+puts "  - All updates happen without page reload (HTMX)"
+puts ""
+puts "JSON API also available at /api/todos"
+puts ""
+
+FunApi::Server::Falcon.start(app, port: 3000)