respondo 2.1.0 → 2.1.2

data/README.md

@@ -1,9 +1,36 @@
+<div align="center">
+
 # Respondo 🎯
 
-[![Gem Version](https://badge.fury.io/rb/respondo.svg?icon=si%3Arubygems&icon_color=%23ce0303)](https://badge.fury.io/rb/respondo)
-![GitHub Repo Views](https://gitviews.com/repo/spatelpatidar/respondo.svg)
+**Consistent JSON API responses for Rails — in one line.**
+
+[![Gem Version](https://badge.fury.io/rb/respondo.svg)](https://rubygems.org/gems/respondo)
+[![Downloads](https://img.shields.io/gem/dt/respondo.svg)](https://rubygems.org/gems/respondo)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+[![Ruby](https://img.shields.io/badge/Ruby-2.7%2B-red)](https://www.ruby-lang.org/)
+
+</div>
+
+---
+
+## The problem every Rails API developer hits
 
-Smart JSON API response formatter for Rails — consistent structure every time, across every app.
+You're building an API consumed by a React frontend and a Flutter app. Three developers on your team. Three different response shapes:
+
+```json
+// Developer A
+{ "data": [...], "status": "ok" }
+
+// Developer B
+{ "result": [...], "success": true }
+
+// Developer C
+{ "users": [...] }
+```
+
+Your frontend devs are writing `if (res.data || res.result || res.users)`. Your Flutter devs are filing bugs. Your code reviews are arguments.
+
+**Respondo fixes this permanently.** One response shape. Every controller. Every developer. Every time.
 
 ```json
 {
@@ -12,860 +39,388 @@ Smart JSON API response formatter for Rails — consistent structure every time,
   "data": [...],
   "meta": {
     "timestamp": "2024-06-15T10:30:00Z",
-    "pagination": {
-      "currentPage": 1,
-      "perPage": 25,
-      "totalPages": 4,
-      "totalCount": 98,
-      "nextPage": 2,
-      "prevPage": null
-    }
+    "pagination": { "currentPage": 1, "totalPages": 4, "totalCount": 98 }
   }
 }
 ```
 
-## The Problem
-
-Different developers return different JSON structures — some use `data`, some use `result`, some forget `success: true`. This makes frontend integration (Flutter, React, etc.) brittle and unpredictable.
-
-Respondo enforces one structure, everywhere, automatically.
-
 ---
 
-## Installation
+## Install
 
 ```ruby
+# Gemfile
 gem "respondo"
 ```
 
----
-
-## Setup
-
-### ✅ Recommended — use the install generator
-
-After adding the gem, run:
-
 ```bash
+bundle install
 rails generate respondo:install
 ```
 
-The interactive wizard walks you through every option and writes a fully commented `config/initializers/respondo.rb` tailored to your project. No need to read the full README or copy-paste config by hand.
+That's it. No `include` in `ApplicationController`. No boilerplate. Respondo auto-injects via Railtie.
 
-```
-  ┌─ Project Info ─────────────────────────────────────────────────────┐
-
-  Project / app name
-  (Used as a comment header in the initializer)
-  › [MyApp]:
-
-  API version  (e.g. v1 — added to every response meta block)
-  › [v1]:
-
-  ┌─ Response Messages ────────────────────────────────────────────────┐
-
-  Default success message
-  › [Success]:
-
-  Default error message
-  › [An error occurred]:
-
-  ...
-```
+---
 
-The generator produces a file like this:
+## Your first response (30 seconds)
 
 ```ruby
-# frozen_string_literal: true
-
-# Respondo initializer — MyApp
-# Generated by: rails generate respondo:install
-# Respondo version: 2.1.0
-
-Respondo.configure do |config|
-
-  # ── Messages ─────────────────────────────────────────────────────────
-  config.default_success_message = "Success"
-  config.default_error_message   = "Something went wrong"
-
-  # ── Request ID ───────────────────────────────────────────────────────
-  config.include_request_id = true
-
-  # ── Key Format ───────────────────────────────────────────────────────
-  config.camelize_keys = true
-
-  # ── Global Meta ──────────────────────────────────────────────────────
-  config.default_meta = {
-    api_version: "v1",
-    platform: "mobile"
-  }
-
-  # ── Custom Serializer ────────────────────────────────────────────────
-  # config.serializer = ->(obj) { MySerializer.new(obj).as_json }
-
-end
-```
-
-Re-run the generator any time to regenerate with different answers — it overwrites the existing initializer.
-
----
-
-### Manual setup (alternative)
+class UsersController < ApplicationController
+  def index
+    render_ok(data: User.all, message: "Users fetched")
+  end
 
-If you prefer to write the initializer yourself, create `config/initializers/respondo.rb`:
+  def create
+    user = User.new(user_params)
+    if user.save
+      render_created(data: user, message: "Account created")
+    else
+      render_unprocessable(message: "Validation failed", errors: user.errors)
+    end
+  end
 
-```ruby
-# config/initializers/respondo.rb
-Respondo.configure do |config|
-  config.default_success_message = "OK"
-  config.default_error_message   = "Something went wrong"
-  config.include_request_id      = true   # adds request_id to every meta
-  config.camelize_keys           = true   # snake_case → camelCase for Flutter/JS
+  def show
+    render_ok(data: User.find(params[:id]), message: "User found")
+  rescue ActiveRecord::RecordNotFound
+    render_not_found(message: "User not found")
+  end
 end
 ```
 
-Respondo auto-includes itself into `ActionController::Base` and `ActionController::API` via Railtie. No manual `include` needed in `ApplicationController`.
+Your frontend now gets a **guaranteed** structure — forever.
 
 ---
 
-## Response Structure
-
-Every single response — success or error — returns the same four keys:
+## Why teams switch to Respondo
 
-| Key       | Type             | Description                                          |
-|-----------|------------------|------------------------------------------------------|
-| `success` | Boolean          | `true` or `false`                                    |
-| `message` | String           | Human-readable description                           |
-| `data`    | Object/Array/nil | The payload                                          |
-| `meta`    | Object           | Timestamp + pagination (if passed) + optional request_id |
-
-Error responses additionally include:
-
-| Key      | Type | Description                          |
-|----------|------|--------------------------------------|
-| `errors` | Hash | Field-level errors `{field: [msgs]}` |
-| `errors` | Hash | Field-level errors `{field: msgs}` |
+| Without Respondo | With Respondo |
+|---|---|
+| Each dev invents their own response format | One standard, enforced automatically |
+| Frontend code full of defensive `||` checks | `response.data` always works |
+| Pagination shape differs per endpoint | Pagination always in `meta.pagination` |
+| Validation errors in different keys | Always in `errors`, always a hash |
+| `render json:` boilerplate in every action | One expressive method call |
+| camelCase conversion scattered across code | `config.camelize_keys = true` — done |
 
 ---
 
-## Complete Helper Reference
+## What every response looks like
 
-### 1xx — Informational Helpers
+Every response — success or error — has the same four keys:
 
-> 1xx responses are protocol-level and carry no body in standard HTTP/1.1. Respondo still returns a JSON body for API logging consistency. Use with care.
+| Key | Type | Description |
+|---|---|---|
+| `success` | Boolean | `true` or `false` — always present |
+| `message` | String | Human-readable description |
+| `data` | Object / Array / nil | The payload |
+| `meta` | Object | Timestamp + pagination + optional `request_id` |
 
-#### `render_continue` — 100
-```ruby
-render_continue
-render_continue(message: "Continue sending request body")
-```
+Error responses additionally include `errors` — a hash of `{ field: ["message"] }`.
 
-#### `render_switching_protocols` — 101
-```ruby
-render_switching_protocols
-render_switching_protocols(message: "Upgrading to WebSocket")
-```
-
-#### `render_processing` — 102
-```ruby
-render_processing
-render_processing(message: "Working on it — please wait")
+**Success:**
+```json
+{
+  "success": true,
+  "message": "Post published",
+  "data": { "id": 42, "title": "Hello World" },
+  "meta": { "timestamp": "2024-06-15T10:30:00Z" }
+}
 ```
 
-#### `render_early_hints` — 103
-```ruby
-render_early_hints
-render_early_hints(message: "Early hints provided", meta: { link: "</style.css>; rel=preload" })
+**Validation error:**
+```json
+{
+  "success": false,
+  "message": "Validation failed",
+  "data": null,
+  "errors": { "email": ["is invalid"], "name": ["can't be blank"] },
+  "meta": { "timestamp": "2024-06-15T10:30:00Z" }
+}
 ```
 
 ---
 
-### 2xx — Success Helpers
-
-#### `render_ok` — 200 OK
-Explicit alias for `render_success`. Use when you want to be more descriptive.
-
-```ruby
-render_ok(data: @user, message: "User found")
-```
-
-#### `render_created` — 201 Created
-Use after a successful POST that creates a resource.
-
-```ruby
-render_created(data: @post, message: "Post published")
-render_created(data: @user)  # uses default "Created successfully" message
-```
-
-#### `render_accepted` — 202 Accepted
-Use for async operations — the request was received but processing happens in the background.
+## Real-world controller (with pagination)
 
 ```ruby
-render_accepted(message: "Your export is being processed. You will receive an email when ready.")
-render_accepted(data: { job_id: "abc123" }, message: "Job queued")
-```
+class PostsController < ApplicationController
 
-#### `render_non_authoritative` — 203 Non-Authoritative Information
-Use when data comes from a third-party or cache rather than the origin server.
+  def index
+    @posts = Post.published.page(params[:page]).per(params[:per_page] || 20)
 
-```ruby
-render_non_authoritative(data: @user, message: "Data sourced from cache")
-```
+    render_ok(
+      data:    @posts,
+      message: "Posts fetched",
+      pagination: {
+        current_page: @posts.current_page,
+        next_page:    @posts.next_page,
+        prev_page:    @posts.prev_page,
+        total_pages:  @posts.total_pages,
+        total_count:  @posts.total_count,
+        per_page:     @posts.limit_value
+      }
+    )
+  end
 
-#### `render_no_content` — 200 OK
-Use after DELETE or actions with no meaningful response body. Returns standard JSON structure for consistency.
+  def create
+    @post = current_user.posts.build(post_params)
 
-```ruby
-render_no_content                                  # "Deleted successfully"
-render_no_content(message: "Account deactivated")
-```
+    if @post.save
+      render_created(data: @post, message: "Post published")
+    else
+      render_unprocessable(message: "Could not create post", errors: @post.errors)
+    end
+  end
 
-#### `render_reset_content` — 205 Reset Content
-Tell the client to reset the document view (e.g. clear a form after submission).
+  def update
+    @post = Post.find(params[:id])
 
-```ruby
-render_reset_content(message: "Form submitted — please reset the view")
-```
+    return render_forbidden(message: "Not your post") unless @post.user == current_user
 
-#### `render_partial_content` — 206 Partial Content
-Use for chunked or range-based responses.
+    if @post.update(post_params)
+      render_ok(data: @post, message: "Post updated")
+    else
+      render_unprocessable(message: "Update failed", errors: @post.errors)
+    end
+  rescue ActiveRecord::RecordNotFound
+    render_not_found(message: "Post not found")
+  end
 
-```ruby
-render_partial_content(data: @chunk, message: "Page 1 of 5")
-render_partial_content(data: @results, meta: { range: "0-99/500" })
+end
 ```
 
-#### `render_multi_status` — 207 Multi-Status
-Use for batch operations where some succeed and some fail.
-
-```ruby
-render_multi_status(
-  data: { created: 8, failed: 2 },
-  message: "Batch completed with partial failures"
-)
-```
+## Auto-Serialization
 
-#### `render_already_reported` — 208 Already Reported
-```ruby
-render_already_reported(data: @resource, message: "Already reported in this binding")
-```
+Respondo automatically handles:
 
-#### `render_im_used` — 226 IM Used
-```ruby
-render_im_used(data: @resource, message: "Delta encoding applied")
-```
+| Input type                       | Output                              |
+|----------------------------------|-------------------------------------|
+| `ActiveRecord::Base` instance    | `record.as_json`                    |
+| `ActiveRecord::Relation`         | Array of `as_json` records          |
+| `ActiveModel::Errors`            | `{ field: ["message", ...] }`       |
+| `Hash`                           | Passed through (values serialized)  |
+| `Array`                          | Each element serialized recursively |
+| `Exception`                      | `{ message: e.message }`            |
+| Anything with `#as_json`         | `.as_json`                          |
+| Anything with `#to_h`            | `.to_h`                             |
+| Primitives (String, Integer...)  | As-is                               |
 
 ---
 
-### 3xx — Redirect Helpers
-
-> These return a JSON body so your API can communicate redirect intent with context.
-> Pass the target URL via `meta: { redirect_url: "..." }`.
-
-#### `render_multiple_choices` — 300
-```ruby
-render_multiple_choices(
-  data: [{ format: "json", url: "/resource.json" }, { format: "xml", url: "/resource.xml" }],
-  message: "Multiple representations available"
-)
-```
-
-#### `render_moved_permanently` — 301
-```ruby
-render_moved_permanently(message: "This endpoint has moved", meta: { redirect_url: new_url })
-```
+## Configuration
 
-#### `render_found` — 302
-```ruby
-render_found(message: "Resource temporarily at another URL", meta: { redirect_url: temp_url })
-```
+Run the interactive generator — it walks you through every option:
 
-#### `render_see_other` — 303
-```ruby
-render_see_other(message: "See the canonical resource", meta: { redirect_url: canonical_url })
+```bash
+rails generate respondo:install
 ```
 
-#### `render_not_modified` — 304
-```ruby
-render_not_modified(message: "Your cached version is still valid")
-```
+Or write it manually:
 
-#### `render_temporary_redirect` — 307
 ```ruby
-render_temporary_redirect(message: "Repeat this request at the redirect URL", meta: { redirect_url: url })
-```
-
-#### `render_permanent_redirect` — 308
-```ruby
-render_permanent_redirect(message: "Permanently moved — update your bookmarks", meta: { redirect_url: url })
+# config/initializers/respondo.rb
+Respondo.configure do |config|
+  config.default_success_message = "OK"
+  config.default_error_message   = "Something went wrong"
+  config.include_request_id      = true   # adds request_id to every meta
+  config.camelize_keys           = true   # snake_case → camelCase (Flutter/JS friendly)
+  config.default_meta            = { api_version: "v1" }
+end
 ```
 
----
-
-### 4xx — Client Error Helpers
+### camelCase output (great for Flutter / React Native)
 
-#### `render_bad_request` — 400 Bad Request
 ```ruby
-render_bad_request(message: "The 'date' parameter is required")
-render_bad_request(message: "Invalid input", errors: { date: ["must be a valid date"] })
+config.camelize_keys = true
 ```
 
-#### `render_unauthorized` — 401 Unauthorized
-```ruby
-render_unauthorized(message: "Please log in to continue")
-render_unauthorized(message: "Token has expired")
+```json
+{
+  "success": true,
+  "data": { "firstName": "Alice", "createdAt": "2024-01-01" },
+  "meta": { "totalPages": 4, "currentPage": 1 }
+}
 ```
 
-#### `render_payment_required` — 402 Payment Required
-```ruby
-render_payment_required(message: "Upgrade to Pro to access this feature")
-```
+### Custom serializer
 
-#### `render_forbidden` — 403 Forbidden
 ```ruby
-render_forbidden(message: "You can only edit your own posts")
+config.serializer = ->(obj) { MySerializer.new(obj).as_json }
 ```
 
-#### `render_not_found` — 404 Not Found
-```ruby
-render_not_found(message: "User not found")
-render_not_found(message: "Post ##{params[:id]} does not exist")
-```
+---
 
-#### `render_method_not_allowed` — 405
-```ruby
-render_method_not_allowed(message: "This endpoint only accepts POST requests")
-```
+## Global error handling (recommended pattern)
 
-#### `render_not_acceptable` — 406
-```ruby
-render_not_acceptable(message: "Only application/json is supported")
-```
+Add this to `ApplicationController` to handle exceptions app-wide without try/rescue in every action:
 
-#### `render_proxy_auth_required` — 407
 ```ruby
-render_proxy_auth_required(message: "Authenticate with the proxy first")
-```
-
-#### `render_request_timeout` — 408
-```ruby
-render_request_timeout(message: "The query took too long. Try a smaller date range.")
-```
+class ApplicationController < ActionController::API
+  rescue_from ActiveRecord::RecordNotFound do |e|
+    render_not_found(message: e.message)
+  end
 
-#### `render_conflict` — 409 Conflict
-```ruby
-render_conflict(message: "Email address is already registered")
-render_conflict(message: "Duplicate entry", errors: { email: ["has already been taken"] })
-```
+  rescue_from ActionController::ParameterMissing do |e|
+    render_bad_request(message: e.message)
+  end
 
-#### `render_gone` — 410 Gone
-```ruby
-render_gone(message: "This account has been permanently deleted")
+  rescue_from StandardError do |e|
+    Rails.logger.error(e.full_message)
+    render_server_error(message: "An unexpected error occurred")
+  end
+end
 ```
 
-#### `render_length_required` — 411
-```ruby
-render_length_required(message: "Content-Length header is required")
-```
+---
 
-#### `render_precondition_failed` — 412
-```ruby
-render_precondition_failed(message: "Resource has been modified since your last request")
-```
+## Complete HTTP helper reference
 
-#### `render_payload_too_large` — 413
-```ruby
-render_payload_too_large(message: "File exceeds the 10 MB upload limit")
-```
+Respondo covers every HTTP status code. Here are the helpers you'll use every day:
 
-#### `render_uri_too_long` — 414
-```ruby
-render_uri_too_long(message: "That URL is too long to process")
-```
+### 2xx — Success
 
-#### `render_unsupported_media_type` — 415
-```ruby
-render_unsupported_media_type(message: "Please send requests as application/json")
-```
+| Helper | Status | When to use |
+|---|---|---|
+| `render_ok` | 200 | Standard success |
+| `render_created` | 201 | After POST creates a resource |
+| `render_accepted` | 202 | Async jobs — request queued |
+| `render_no_content` | 200* | After DELETE — no body |
 
-#### `render_range_not_satisfiable` — 416
-```ruby
-render_range_not_satisfiable(message: "Requested byte range is out of bounds")
-```
+> *Rails renders 200 with a JSON body for `render_no_content` to preserve consistent structure.
 
-#### `render_expectation_failed` — 417
 ```ruby
-render_expectation_failed(message: "Expect header value cannot be met")
+render_ok(data: @user, message: "Profile fetched")
+render_created(data: @order, message: "Order placed")
+render_accepted(data: { job_id: "abc123" }, message: "Export queued — you'll get an email")
+render_no_content(message: "Account deleted")
 ```
 
-#### `render_im_a_teapot` — 418
-```ruby
-render_im_a_teapot(message: "I'm a teapot — I cannot brew coffee")
-```
-
-#### `render_misdirected_request` — 421
-```ruby
-render_misdirected_request(message: "Request sent to the wrong server")
-```
+### 4xx — Client errors
 
-#### `render_unprocessable` — 422 Unprocessable Entity
-Validation errors. The most commonly used error helper in Rails APIs.
+| Helper | Status | When to use |
+|---|---|---|
+| `render_bad_request` | 400 | Malformed input |
+| `render_unauthorized` | 401 | Not logged in / token expired |
+| `render_forbidden` | 403 | Logged in but not allowed |
+| `render_not_found` | 404 | Record doesn't exist |
+| `render_conflict` | 409 | Duplicate (e.g. email taken) |
+| `render_unprocessable` | 422 | Validation errors |
+| `render_too_many_requests` | 429 | Rate limiting |
 
 ```ruby
+render_unauthorized(message: "Token has expired", errors: { token: ["has expired"] })
+render_forbidden(message: "You can only edit your own posts")
+render_not_found(message: "User ##{params[:id]} not found")
 render_unprocessable(message: "Validation failed", errors: user.errors)
-render_unprocessable(message: "Invalid data", errors: { name: ["can't be blank"] })
-```
-
-#### `render_locked` — 423
-```ruby
-render_locked(message: "This record is locked by another user")
-```
-
-#### `render_failed_dependency` — 424
-```ruby
-render_failed_dependency(message: "Prerequisite resource creation failed")
-```
-
-#### `render_too_early` — 425
-```ruby
-render_too_early(message: "Request may be a replay — rejected for safety")
-```
-
-#### `render_upgrade_required` — 426
-```ruby
-render_upgrade_required(message: "Please upgrade to TLS 1.3")
-```
-
-#### `render_precondition_required` — 428
-```ruby
-render_precondition_required(message: "Include an If-Match header with your request")
-```
-
-#### `render_too_many_requests` — 429
-```ruby
-render_too_many_requests(message: "You have exceeded 100 requests per minute.")
-render_too_many_requests(message: "Rate limit hit", meta: { retry_after: 60 })
-```
-
-#### `render_request_header_fields_too_large` — 431
-```ruby
-render_request_header_fields_too_large(message: "Cookie header is too large")
-```
-
-#### `render_unavailable_for_legal_reasons` — 451
-```ruby
-render_unavailable_for_legal_reasons(message: "This content is blocked in your region")
+render_conflict(message: "Email already registered", errors: { email: ["has already been taken"] })
+render_too_many_requests(message: "Slow down — 100 req/min max", meta: { retry_after: 60 })
 ```
 
----
-
-### 5xx — Server Error Helpers
+### 5xx — Server errors
 
-#### `render_server_error` — 500 Internal Server Error
 ```ruby
 render_server_error(message: "Something went wrong. Our team has been notified.")
-
-# Common pattern — rescue unexpected exceptions
-rescue StandardError => e
-  Rails.logger.error(e)
-  render_server_error("An unexpected error occurred")
+render_service_unavailable(message: "Down for maintenance. Back in 30 minutes.", meta: { retry_after: 1800 })
+render_bad_gateway(message: "Payment processor is unreachable — you have not been charged")
 ```
 
-#### `render_not_implemented` — 501
-```ruby
-render_not_implemented(message: "CSV export is coming soon")
-```
+<details>
+<summary><strong>Full list of all helpers (click to expand)</strong></summary>
 
-#### `render_bad_gateway` — 502
-```ruby
-render_bad_gateway(message: "Payment gateway is currently unavailable")
-```
+#### 1xx — Informational
+`render_continue` · `render_switching_protocols` · `render_processing` · `render_early_hints`
 
-#### `render_service_unavailable` — 503
-```ruby
-render_service_unavailable(message: "Down for maintenance. Back in 30 minutes.")
-render_service_unavailable(message: "Maintenance window", meta: { retry_after: 1800 })
-```
+#### 2xx — Success
+`render_ok` · `render_created` · `render_accepted` · `render_non_authoritative` · `render_no_content` · `render_reset_content` · `render_partial_content` · `render_multi_status` · `render_already_reported` · `render_im_used`
 
-#### `render_gateway_timeout` — 504
-```ruby
-render_gateway_timeout(message: "The payment processor did not respond in time.")
-```
+#### 3xx — Redirect
+`render_multiple_choices` · `render_moved_permanently` · `render_found` · `render_see_other` · `render_not_modified` · `render_temporary_redirect` · `render_permanent_redirect`
 
-#### `render_http_version_not_supported` — 505
-```ruby
-render_http_version_not_supported(message: "Only HTTP/1.1 and HTTP/2 are supported")
-```
+#### 4xx — Client Error
+`render_bad_request` · `render_unauthorized` · `render_payment_required` · `render_forbidden` · `render_not_found` · `render_method_not_allowed` · `render_not_acceptable` · `render_proxy_auth_required` · `render_request_timeout` · `render_conflict` · `render_gone` · `render_length_required` · `render_precondition_failed` · `render_payload_too_large` · `render_uri_too_long` · `render_unsupported_media_type` · `render_range_not_satisfiable` · `render_expectation_failed` · `render_im_a_teapot` · `render_misdirected_request` · `render_unprocessable` · `render_locked` · `render_failed_dependency` · `render_too_early` · `render_upgrade_required` · `render_precondition_required` · `render_too_many_requests` · `render_request_header_fields_too_large` · `render_unavailable_for_legal_reasons`
 
-#### `render_variant_also_negotiates` — 506
-```ruby
-render_variant_also_negotiates(message: "Server content-negotiation loop detected")
-```
+#### 5xx — Server Error
+`render_server_error` · `render_not_implemented` · `render_bad_gateway` · `render_service_unavailable` · `render_gateway_timeout` · `render_http_version_not_supported` · `render_variant_also_negotiates` · `render_insufficient_storage` · `render_loop_detected` · `render_not_extended` · `render_network_authentication_required`
 
-#### `render_insufficient_storage` — 507
-```ruby
-render_insufficient_storage(message: "Disk quota exceeded on this node")
-```
-
-#### `render_loop_detected` — 508
-```ruby
-render_loop_detected(message: "Infinite redirect loop detected")
-```
-
-#### `render_not_extended` — 510
-```ruby
-render_not_extended(message: "Further extensions required to fulfil this request")
-```
-
-#### `render_network_authentication_required` — 511
-```ruby
-render_network_authentication_required(message: "Sign in to the network portal first")
-```
+</details>
 
 ---
 
-## Real-World Controller Examples
-
-```ruby
-class UsersController < ApplicationController
+## Testing your responses
 
-  def index
-    page     = (params[:page]     || 1).to_i
-    per_page = (params[:per_page] || 5).to_i
+Respondo ships with test helpers for RSpec and Minitest so you can assert on response structure directly.
 
-    @users =  Kaminari.paginate_array(User.active).page(page).per(per_page)
+### RSpec
 
-    render_ok(
-      data:       @users,
-      message:    "Users fetched",
-      pagination: {
-        per_page: per_page.to_i,
-        current_page: @users.current_page,
-        next_page: @users.next_page,
-        prev_page: @users.prev_page,
-        total_pages: @users.total_pages,
-        total_count: @users.total_count
-      }
-    )
-  end
-
-  def show
-    user = User.find(params[:id])
-    render_ok(data: user, message: "User found")
-  rescue ActiveRecord::RecordNotFound
-    render_not_found(message: "User ##{params[:id]} not found", error: { id: "User #{params[:id]} not exist"})
-  end
+```ruby
+# spec/rails_helper.rb
+require "respondo/testing/rspec"
 
-  def create
-    user = User.new(user_params)
-    if user.save
-      render_created(data: user, message: "Account created successfully")
-    else
-      render_unprocessable(message: "Validation failed", errors: user.errors)
+RSpec.describe UsersController, type: :request do
+  describe "GET /users" do
+    it "returns a success response" do
+      get "/users"
+      expect(response).to be_respondo_success
+      expect(response).to have_respondo_message("Users fetched")
     end
   end
 
-  def update
-    user = User.find(params[:id])
-
-    unless user == current_user || current_user.admin?
-      render_forbidden(message: "You can only update your own profile", error: { profile: "update your own profile" })
-      return
-    end
-
-    if user.update(user_params)
-      render_ok(data: user, message: "Profile updated")
-    else
-      render_conflict(message: "Could not update profile", errors: user.errors)
+  describe "POST /users with invalid params" do
+    it "returns validation errors" do
+      post "/users", params: { user: { email: "" } }
+      expect(response).to be_respondo_error
+      expect(response).to have_respondo_errors(:email)
     end
   end
-
-  def destroy
-    User.find(params[:id]).destroy!
-    render_no_content(message: "Account deleted")
-  rescue ActiveRecord::RecordNotFound
-    render_gone(message: "This account no longer exists")
-  end
-
-end
-
-class PaymentsController < ApplicationController
-
-  def create
-    result = PaymentGateway.charge(amount: params[:amount], token: params[:token])
-    render_created(data: result, message: "Payment successful")
-  rescue PaymentGateway::CardDeclined => e
-    render_unprocessable(message: e.message)
-  rescue PaymentGateway::Timeout
-    render_gateway_timeout(message: "Payment processor timed out. You have not been charged.")
-  rescue PaymentGateway::Error => e
-    render_bad_gateway(message: "Payment gateway error: #{e.message}")
-  end
-
-end
-
-class ReportsController < ApplicationController
-
-  def generate
-    ReportJob.perform_later(current_user.id, params[:type])
-    render_accepted(
-      data:    { estimated_time: "2 minutes" },
-      message: "Report is being generated. We will email you when it is ready."
-    )
-  end
-
-end
-```
-
----
-
-## Pagination
-
-Respondo does **not** paginate data for you — your pagination library does that.
-You build the pagination hash yourself and pass it via `pagination:`. This keeps the gem simple, dependency-free, and works with any library.
-
-### Kaminari
-
-```ruby
-def index
-  @users = User.page(params[:page]).per(25)
-
-  render_ok(
-    data:       @users,
-    message:    "Users fetched",
-    pagination: {
-      current_page: @users.current_page,
-      per_page:     @users.limit_value,
-      total_pages:  @users.total_pages,
-      total_count:  @users.total_count,
-      next_page:    @users.next_page,
-      prev_page:    @users.prev_page
-    }
-  )
 end
 ```
 
-### Pagy
+### Minitest
 
 ```ruby
-def index
-  @pagy, @users = pagy(User.all, items: 25)
-
-  render_ok(
-    data:       @users,
-    message:    "Users fetched",
-    pagination: {
-      current_page: @pagy.page,
-      per_page:     @pagy.items,
-      total_pages:  @pagy.pages,
-      total_count:  @pagy.count,
-      next_page:    @pagy.next,
-      prev_page:    @pagy.prev
-    }
-  )
-end
-```
-
-### WillPaginate
-
-```ruby
-def index
-  @users = User.paginate(page: params[:page], per_page: 25)
-
-  render_ok(
-    data:       @users,
-    message:    "Users fetched",
-    pagination: {
-      current_page: @users.current_page,
-      per_page:     @users.per_page,
-      total_pages:  @users.total_pages,
-      total_count:  @users.total_entries,
-      next_page:    @users.next_page,
-      prev_page:    @users.previous_page
-    }
-  )
-end
-```
-
-### No pagination
+# test/test_helper.rb
+require "respondo/testing/minitest"
 
-```ruby
-render_ok(data: @user, message: "User found")
-# → meta will have no pagination key at all
-```
-
----
-
-## Quick Reference Card
-
-```ruby
-# Core
-render_success(data:, message:, meta:, code:, pagination:, code:, status:)
-render_error(message:, errors:, code:, meta:, status:)
-
-# 1xx — Informational
-render_continue(message:, meta:)
-render_switching_protocols(message:, meta:)
-render_processing(message:, meta:)
-render_early_hints(message:, meta:)
-
-# 2xx — Success
-render_success(data:, message:, meta:, pagination:, code: , status:)
-render_ok(data:, message:, meta:, pagination:)
-render_created(data:, message:, meta:, pagination:)
-render_accepted(data:, message:, meta:, pagination:)
-render_non_authoritative(data:, message:, meta:, pagination:)
-render_no_content(message:, meta:, pagination:)
-render_reset_content(message:, meta:, pagination:)
-render_partial_content(data:, message:, meta:, pagination:)
-render_multi_status(data:, message:, meta:, pagination:)
-render_already_reported(data:, message:, meta:, pagination:)
-render_im_used(data:, message:, meta:, pagination:)
-
-# 3xx — Redirects
-render_multiple_choices(data:, message:, meta:, pagination:)
-render_moved_permanently(message:, meta:, pagination:)
-render_found(message:, meta:, pagination:)
-render_see_other(message:, meta:, pagination:)
-render_not_modified(message:, meta:, pagination:)
-render_temporary_redirect(message:, meta:, pagination:)
-render_permanent_redirect(message:, meta:, pagination:)
-
-# 4xx — Client Errors
-render_bad_request(message:, errors:, meta:)
-render_unauthorized(message:, errors:, meta:)
-render_payment_required(message:, errors:, meta:)
-render_forbidden(message:, errors:, meta:)
-render_not_found(message:, errors:, meta:)
-render_method_not_allowed(message:, errors:, meta:)
-render_not_acceptable(message:, errors:, meta:)
-render_proxy_auth_required(message:, errors:, meta:)
-render_request_timeout(message:, errors:, meta:)
-render_conflict(message:, errors:, meta:)
-render_gone(message:, errors:, meta:)
-render_length_required(message:, errors:, meta:)
-render_precondition_failed(message:, errors:, meta:)
-render_payload_too_large(message:, errors:, meta:)
-render_uri_too_long(message:, errors:, meta:)
-render_unsupported_media_type(message:, errors:, meta:)
-render_range_not_satisfiable(message:, errors:, meta:)
-render_expectation_failed(message:, errors:, meta:)
-render_im_a_teapot(message:, errors:, meta:)
-render_misdirected_request(message:, errors:, meta:)
-render_unprocessable(message:, errors:, meta:)
-render_locked(message:, errors:, meta:)
-render_failed_dependency(message:, errors:, meta:)
-render_too_early(message:, errors:, meta:)
-render_upgrade_required(message:, errors:, meta:)
-render_precondition_required(message:, errors:, meta:)
-render_too_many_requests(message:, errors:, meta:)
-render_request_header_fields_too_large(message:, errors:, meta:)
-render_unavailable_for_legal_reasons(message:, errors:, meta:)
-
-# 5xx — Server Errors
-render_server_error(message:, errors:, meta:)
-render_not_implemented(message:, errors:, meta:)
-render_bad_gateway(message:, errors:, meta:)
-render_service_unavailable(message:, errors:, meta:)
-render_gateway_timeout(message:, errors:, meta:)
-render_http_version_not_supported(message:, errors:, meta:)
-render_variant_also_negotiates(message:, errors:, meta:)
-render_insufficient_storage(message:, errors:, meta:)
-render_loop_detected(message:, errors:, meta:)
-render_not_extended(message:, errors:, meta:)
-render_network_authentication_required(message:, errors:, meta:)
-```
-
----
-
-## Auto-Serialization
-
-Respondo automatically handles:
-
-| Input type                       | Output                              |
-|----------------------------------|-------------------------------------|
-| `ActiveRecord::Base` instance    | `record.as_json`                    |
-| `ActiveRecord::Relation`         | Array of `as_json` records          |
-| `ActiveModel::Errors`            | `{ field: ["message", ...] }`       |
-| `Hash`                           | Passed through (values serialized)  |
-| `Array`                          | Each element serialized recursively |
-| `Exception`                      | `{ message: e.message }`            |
-| Anything with `#as_json`         | `.as_json`                          |
-| Anything with `#to_h`            | `.to_h`                             |
-| Primitives (String, Integer...)  | As-is                               |
-
-### Custom serializer
-
-```ruby
-Respondo.configure do |config|
-  # Use ActiveModelSerializers, Blueprinter, Panko, etc.
-  config.serializer = ->(obj) { UserSerializer.new(obj).as_json }
+class UsersControllerTest < ActionDispatch::IntegrationTest
+  def test_index_returns_success
+    get users_url
+    assert_respondo_success response
+    assert_respondo_message "Users fetched", response
+  end
 end
 ```
 
 ---
 
-## camelCase for Flutter / JavaScript
+## What's next
 
-```ruby
-Respondo.configure { |c| c.camelize_keys = true }
-```
+- [ ] ActiveModelSerializers / Blueprinter auto-integration
+- [ ] OpenAPI / Swagger schema generation from Respondo helpers
+- [ ] Rack middleware for zero-config global exception handling
 
-All keys in the response — including nested `meta.pagination` — are camelized:
-`current_page` → `currentPage`, `total_count` → `totalCount`, `next_page` → `nextPage`, `error_code` → `errorCode`.
-
-### Flutter Integration
-
-```dart
-// Every response follows the same shape
-class ApiResponse<T> {
-  final bool success;
-  final String message;
-  final T? data;
-  final Map<String, dynamic> meta;
-  final Map<String, dynamic>? errors;
-
-  const ApiResponse({
-    required this.success,
-    required this.message,
-    this.data,
-    required this.meta,
-    this.errors,
-  });
-}
-```
+Have a feature idea? [Open an issue →](https://github.com/spatelpatidar/respondo/issues)
 
 ---
 
-## Architecture
+## Contributing
 
-```
-lib/
-├── respondo.rb                    # Entry point, configure, Railtie hook
-├── respondo/
-│   ├── version.rb                 # VERSION
-│   ├── configuration.rb           # Config with defaults
-│   ├── serializer.rb              # Auto-detects and serializes any object
-│   ├── response_builder.rb        # Assembles the final Hash
-│   ├── controller_helpers.rb      # All render_* helpers (1xx–5xx)
-│   └── railtie.rb                 # Auto-includes into Rails controllers
-└── generators/
-    └── respondo/
-        └── install/
-            └── install_generator.rb   # rails generate respondo:install
-```
-
----
-
-## Running Tests
+Bug reports and pull requests are welcome on [GitHub](https://github.com/spatelpatidar/respondo).
 
 ```bash
+git clone https://github.com/spatelpatidar/respondo
+cd respondo
 bundle install
-bundle exec rspec --format documentation
+bundle exec rspec
 ```
 
 ---
 
 ## License
 
-MIT
+Released under the [MIT License](LICENSE).
+
+---
+
+<div align="center">
+  <sub>If Respondo saved you an hour, give it a ⭐ — it helps other developers find it.</sub>
+</div>