action_figure 0.6.2 → 0.7.0

data/docs/response-formatters.md

@@ -12,7 +12,7 @@ class UsersController < ApplicationController
 end
 ```
 
-The **formatter** determines the shape of the JSON envelope wrapping your data. ActionFigure ships with four built-in formatters: Default, JSend, JSON:API, and Wrapped.
+The **formatter** determines the shape of the JSON envelope wrapping your data. ActionFigure ships with five built-in formatters: Default, JSend, JSON:API, Wrapped, and RFC 9457.
 
 ## Choosing a Format
 
@@ -39,6 +39,11 @@ class Users::CreateAction
   include ActionFigure[:wrapped]
 end
 
+# Explicit RFC 9457
+class Users::CreateAction
+  include ActionFigure[:rfc_9457]
+end
+
 # Uses the configured default (Default unless changed)
 class Users::CreateAction
   include ActionFigure
@@ -47,7 +52,7 @@ end
 
 ## Response Helpers
 
-Every formatter implements the same nine response helpers. Eight return a hash with `:json` and `:status` keys. `NoContent` returns only `:status`.
+Every formatter implements the same twelve response helpers. Eleven return a hash with `:json` and `:status` keys. `NoContent` returns only `:status`.
 
 | Helper                          | HTTP Status              | When to Use                                      |
 |---------------------------------|--------------------------|--------------------------------------------------|
@@ -59,7 +64,10 @@ Every formatter implements the same nine response helpers. Eight return a hash w
 | `Forbidden(errors:)`            | `403 Forbidden`          | Authorization failure                            |
 | `NotFound(errors:)`             | `404 Not Found`          | Resource not found                               |
 | `Conflict(errors:)`             | `409 Conflict`           | Resource state conflict or duplicate             |
+| `Gone(errors:)`                 | `410 Gone`               | Resource permanently deleted (not just 404)      |
 | `UnprocessableContent(errors:)` | `422 Unprocessable Content` | Validation failures                           |
+| `Locked(errors:)`               | `423 Locked`             | Resource locked by another process               |
+| `UnavailableForLegalReasons(errors:)` | `451 Unavailable For Legal Reasons` | Resource censored for legal/regional reasons |
 
 `NoContent` is shared across all formatters and is defined in the base `Formatter` module. It returns `{ status: :no_content }` with no JSON body.
 
@@ -67,11 +75,11 @@ ActionFigure provides helpers for the status codes most commonly returned by act
 
 ## Default Format
 
-The default formatter produces Rails-style responses: the resource is the top-level JSON on success, and errors live under an `"errors"` key on failure. This is the configured default format — bare `include ActionFigure` uses it unless you change `config.format`.
+The default formatter produces Rails-style responses: the resource lives under a `"data"` key on success, and errors live under an `"errors"` key on failure. This is the configured default format — bare `include ActionFigure` uses it unless you change `config.format`.
 
 ### Success Responses
 
-The resource you pass becomes the entire JSON body with no wrapper.
+The resource you pass is wrapped in a `{ "data": ... }` envelope.
 
 **`Ok` -- returning a single resource:**
 
@@ -85,9 +93,11 @@ end
 
 ```json
 {
-  "id": 1,
-  "name": "Jane Doe",
-  "email": "jane@example.com"
+  "data": {
+    "id": 1,
+    "name": "Jane Doe",
+    "email": "jane@example.com"
+  }
 }
 ```
 
@@ -105,15 +115,17 @@ end
 
 ```json
 {
-  "id": 42,
-  "name": "Jane Doe",
-  "email": "jane@example.com"
+  "data": {
+    "id": 42,
+    "name": "Jane Doe",
+    "email": "jane@example.com"
+  }
 }
 ```
 
 **`Ok` -- with metadata:**
 
-When `meta:` is provided, the response wraps the resource under a `"data"` key so that `"meta"` can sit alongside it:
+When `meta:` is provided, `"meta"` sits alongside `"data"`:
 
 ```ruby
 def call(params:)
@@ -135,10 +147,10 @@ end
 }
 ```
 
-Without `meta:`, the resource is the entire body. With `meta:`, the response becomes `{ "data": resource, "meta": meta }`.
-
 **`Accepted` -- with no resource:**
 
+Without a resource, `"data"` is `null` (the key is always present):
+
 ```ruby
 def call(params:)
   OrderFulfillmentJob.perform_later(params[:order_id])
@@ -147,7 +159,9 @@ end
 ```
 
 ```json
-{}
+{
+  "data": null
+}
 ```
 
 **`Accepted` -- with a resource:**
@@ -162,8 +176,10 @@ end
 
 ```json
 {
-  "order_id": 7,
-  "status": "processing"
+  "data": {
+    "order_id": 7,
+    "status": "processing"
+  }
 }
 ```
 
@@ -985,9 +1001,159 @@ end
 }
 ```
 
+## RFC 9457 Format
+
+The RFC 9457 formatter renders errors as [RFC 9457](https://www.rfc-editor.org/rfc/rfc9457) problem documents (`Content-Type: application/problem+json`). Success responses use the same `type`/`title` vocabulary, though RFC 9457 itself only covers errors.
+
+### Success Responses
+
+Success responses place the resource under a key derived from its class name and carry `type` and `title` members.
+
+**`Created` -- returning a model resource:**
+
+```ruby
+def call(params:)
+  user = User.create(params)
+  return UnprocessableContent(errors: user.errors.messages) if user.errors.any?
+
+  Created(
+    resource: user,
+    type: "https://api.example.com/success/user-created",
+    title: "User created"
+  )
+end
+```
+
+```json
+{
+  "type": "https://api.example.com/success/user-created",
+  "title": "User created",
+  "user": { "id": 42, "name": "Jane Doe", "email": "jane@example.com" }
+}
+```
+
+Without explicit `type:` and `title:`, the formatter derives them from the resource class and status — `User` + `Created` → `type: "user-created"`, `title: "User created"`. For `Ok`, `User` + `Ok` → `type: "user-ok"`, `title: "User ok"` — deliberately awkward. Pass explicit values your clients can rely on.
+
+Hash and primitive resources fall back to the key `data` and the name `resource`:
+
+```ruby
+Created(resource: { order_id: 7, status: "queued" })
+# -> type: "resource-created", title: "Resource created", data: { ... }
+```
+
+Override the derived name with `as:`:
+
+```ruby
+Created(resource: some_hash, as: :order)
+# -> type: "order-created", title: "Order created", order: { ... }
+```
+
+**`Accepted` -- with no resource:**
+
+```ruby
+def call(params:)
+  OrderFulfillmentJob.perform_later(params[:order_id])
+  Accepted()
+end
+```
+
+```json
+{
+  "type": "resource-accepted",
+  "title": "Resource accepted"
+}
+```
+
+### Failure Responses
+
+Failure responses produce RFC 9457 problem documents. All members except `type`, `title`, and `status` are optional.
+
+**`UnprocessableContent` -- validation errors:**
+
+`UnprocessableContent` defaults to `type: "unprocessable-content-error"`, so schema validation failures work without any configuration:
+
+```ruby
+def call(params:)
+  user = User.new(params)
+  return UnprocessableContent(errors: user.errors.messages) unless user.save
+  resource = UserBlueprint.render_as_hash(user)
+  Created(resource:, type: "https://api.example.com/success/user-created", title: "User created")
+end
+```
+
+```json
+{
+  "type": "unprocessable-content-error",
+  "title": "Unprocessable Content",
+  "status": 422,
+  "errors": {
+    "email": ["has already been taken"],
+    "name": ["can't be blank"]
+  }
+}
+```
+
+Override `type:` and `title:` when you want a domain-specific URI:
+
+```ruby
+UnprocessableContent(
+  errors: user.errors.messages,
+  type: "https://api.example.com/problems/validation-error",
+  title: "Validation failed"
+)
+```
+
+**`NotFound` -- with `detail` and `instance`:**
+
+```ruby
+def call(params:)
+  user = User.find_by(id: params[:id])
+  return NotFound(
+    type: "https://api.example.com/problems/user-not-found",
+    title: "User not found",
+    detail: "No user with id #{params[:id]} exists.",
+    instance: "/users/#{params[:id]}"
+  ) unless user
+  Ok(resource: user, type: "https://api.example.com/success/user-ok", title: "User found")
+end
+```
+
+```json
+{
+  "type": "https://api.example.com/problems/user-not-found",
+  "title": "User not found",
+  "status": 404,
+  "detail": "No user with id 99 exists.",
+  "instance": "/users/99"
+}
+```
+
+Extra kwargs become extension members in the problem document:
+
+```ruby
+PaymentRequired(
+  type: "https://api.example.com/problems/quota-exceeded",
+  title: "Quota exceeded",
+  balance: 0,
+  limit: 100
+)
+```
+
+```json
+{
+  "type": "https://api.example.com/problems/quota-exceeded",
+  "title": "Quota exceeded",
+  "status": 402,
+  "balance": 0,
+  "limit": 100
+}
+```
+
+`UnprocessableContent` defaults to `type: "unprocessable-content-error"`. All other error helpers derive `type` from the action class and status — `Projects::FindAction` + `NotFound` → `"projects-find-not-found-error"`. Provide a stable URI; the default is intentionally unattractive.
+
 ## The `meta:` Keyword
 
-The `meta:` keyword argument is available on `Ok`, `Created`, and `Accepted`. It accepts any hash, which is included as a top-level `"meta"` key in all four formatters. When `meta:` is `nil` (the default), the key is omitted entirely from the response. In the default formatter, providing `meta:` wraps the response in `{ "data": resource, "meta": meta }` — without `meta:`, the resource is the entire body.
+The `meta:` keyword argument is available on `Ok`, `Created`, and `Accepted`. It accepts any hash, which is included as a top-level `"meta"` key in all five formatters. When `meta:` is `nil` (the default), the key is omitted entirely from the response.
 
 Common uses for `meta:`:
 

data/docs/status-codes.md

@@ -14,7 +14,7 @@ Rows in **bold** are status codes with built-in formatter methods — action cla
 | 407    | Proxy Auth Required              | Perimeter | Infrastructure   | Similar to 401, but for a proxy server.                              |
 | 408    | Request Timeout                  | Perimeter | Server/Nginx     | The client took too long to send the request.                        |
 | **409** | **Conflict**                    | **Domain** | **Action Class** | **Resource already exists, or the state is in conflict.**           |
-| 410    | Gone                             | Domain    | Action Class     | The resource is permanently deleted (not just 404).                  |
+| **410** | **Gone**                        | **Domain** | **Action Class** | **The resource is permanently deleted (not just 404).**             |
 | 411    | Length Required                  | Perimeter | Server/Rack      | The request didn't specify a Content-Length.                         |
 | 412    | Precondition Failed              | Perimeter | Controller/Rack  | If-Match headers don't match (usually for caching).                  |
 | 413    | Payload Too Large                | Perimeter | Server/Nginx     | The request body is bigger than the server allows.                   |
@@ -25,11 +25,13 @@ Rows in **bold** are status codes with built-in formatter methods — action cla
 | 418    | I'm a teapot                     | Domain    | Action Class     | An IETF April Fools joke (rarely used in production).                |
 | 421    | Misdirected Request              | Perimeter | Infrastructure   | The server can't produce a response for this connection.             |
 | **422** | **Unprocessable Content**       | **Domain** | **Action Class** | **Semantic errors (validation, business rules).**                   |
-| 423    | Locked                           | Domain    | Action Class     | The resource is being accessed by another process.                   |
+| **423** | **Locked**                      | **Domain** | **Action Class** | **The resource is being accessed by another process.**              |
 | 424    | Failed Dependency                | Domain    | Action Class     | The request failed due to a failure of a previous request.           |
 | 425    | Too Early                        | Perimeter | Server/Rack      | The server is unwilling to process a request that might be replayed. |
 | 426    | Upgrade Required                 | Perimeter | Server/Rack      | The client must switch to a different protocol (e.g., TLS).          |
 | 428    | Precondition Required            | Perimeter | Controller/Rack  | The server requires the request to be conditional.                   |
 | 429    | Too Many Requests                | Perimeter | Rack::Attack     | Infrastructure-level rate limiting (IP-based, etc.).                 |
 | 431    | Request Header Fields Too Large  | Perimeter | Server/Rack      | HTTP headers are too large.                                          |
-| 451    | Unavailable For Legal Reasons    | Domain    | Action Class     | Resource censored/blocked for legal/regional reasons.                |
+| **451** | **Unavailable For Legal Reasons** | **Domain** | **Action Class** | **Resource censored/blocked for legal/regional reasons.**          |
+
+Any other status — including 5xx codes such as 502 Bad Gateway — can be added with `ActionFigure.register_error(:BadGateway, :bad_gateway)`. The status symbol is validated against Rack's status table at registration, so a typo raises `ArgumentError` at boot. 5xx codes are a deliberate opt-out from the domain/perimeter split and are not built in by default.

data/docs/testing.md

@@ -35,6 +35,11 @@ end
 | `assert_Forbidden(result)`            | `:forbidden`             |
 | `assert_Conflict(result)`             | `:conflict`              |
 | `assert_PaymentRequired(result)`      | `:payment_required`      |
+| `assert_Gone(result)`                 | `:gone`                  |
+| `assert_Locked(result)`               | `:locked`                |
+| `assert_UnavailableForLegalReasons(result)` | `:unavailable_for_legal_reasons` |
+
+Each status assertion has a negated counterpart — **`refute_Ok`**, **`refute_Created`**, … — that passes when the status is anything *other* than the named one. Statuses added with `ActionFigure.register_error` get matching `assert_*`/`refute_*` helpers automatically, whether registered before or after this adapter loads.
 
 These helpers compare **only `result[:status]`** against the Rack-style symbol Rails uses in **`render`** — they **do not** assert on **`[:json]`** keys, payloads, or error message text. Combine them with assertions on **`result[:json]`** (or matchers on the body your formatter produces) whenever shape matters.
 
@@ -50,6 +55,18 @@ When a status assertion fails, the default message shows the expected and actual
 Expected result status to be :ok, but got :unprocessable_content
 ```
 
+### Asserting on the body
+
+Use **`assert_action_json`** to match a (possibly nested) subset of **`result[:json]`** — the Minitest counterpart to RSpec's **`have_action_json`**. Nested Hashes match as subsets, and **`Regexp`** values match against strings:
+
+```ruby
+assert_action_json(result, status: "success")
+assert_action_json(result, status: "success", data: { name: "Jane" })
+assert_action_json(result, data: { email: /@example\.com\z/ })
+```
+
+**`refute_action_json`** passes when the fragment does **not** match. Both fail with a clear message when given a non-result value or a hash missing the **`:json`** key.
+
 ---
 
 ## RSpec
@@ -78,7 +95,12 @@ require "action_figure/testing/rspec"
 | `be_Forbidden`            | `:forbidden`             |
 | `be_Conflict`             | `:conflict`              |
 | `be_PaymentRequired`      | `:payment_required`      |
+| `be_Gone`                 | `:gone`                  |
+| `be_Locked`               | `:locked`                |
+| `be_UnavailableForLegalReasons` | `:unavailable_for_legal_reasons` |
 | `have_action_json`        | `result[:json]` matches `a_hash_including(fragment)` |
+| `accept_params(params)`   | action class's contract accepts `params` |
+| `reject_params(params)`   | action class's contract rejects `params` (chain `.with_error_on(:field)`) |
 
 Like the Minitest helpers, each **`be_*`** matcher compares **only `result[:status]`** — **`[:json]`** is ignored unless you assert on it separately. Use **`have_action_json`** when you want a focused assertion against the **`json`** body (compose with **`a_hash_including`** for nested subsets):
 
@@ -279,6 +301,49 @@ class Users::CreateActionTest < Minitest::Test
 end
 ```
 
+### Contract assertion helpers
+
+The testing adapters wrap the `.contract.call` boilerplate above in intention-revealing helpers. They are **formatter-agnostic** — they exercise the validation pipeline directly, so the same assertions work regardless of which formatter the action includes.
+
+**Minitest** — the subject is the action class:
+
+```ruby
+class Users::CreateActionTest < Minitest::Test
+  include ActionFigure::Testing::Minitest
+
+  def test_accepts_valid_params
+    assert_valid_params(Users::CreateAction, { email: "jane@example.com", name: "Jane" })
+  end
+
+  def test_requires_email
+    # passes when the contract rejects the params at all
+    assert_invalid_params(Users::CreateAction, { name: "Jane" })
+
+    # scope to a field: passes only when :email is among the errors
+    assert_invalid_params(Users::CreateAction, { name: "Jane" }, on: :email)
+  end
+end
+```
+
+**RSpec** — the subject is the action class, not a result hash:
+
+```ruby
+RSpec.describe Users::CreateAction do
+  it "accepts valid params" do
+    expect(Users::CreateAction).to accept_params(email: "jane@example.com", name: "Jane")
+  end
+
+  it "requires email" do
+    expect(Users::CreateAction).to reject_params(name: "Jane")
+    expect(Users::CreateAction).to reject_params(name: "Jane").with_error_on(:email)
+  end
+end
+```
+
+Both adapters raise a clear **`ArgumentError`** when the action class declares no **`params_schema`** (and therefore has no contract to validate against).
+
+> **Validation errors vs. error bodies.** These helpers are the right tool for asserting *validation* behavior. There is no formatter-agnostic helper for **non-validation** error bodies (e.g. a `NotFound`/`Conflict` you return with a custom `errors:` payload) — each formatter stores those differently and the result hash carries no formatter identity. Assert those with a format-specific `assert_action_json` / `have_action_json`.
+
 ---
 
 ## Conventions

data/lib/action_figure/error_registry.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+require "rack/utils"
+
+module ActionFigure
+  # Central registry mapping error-helper names (e.g. +:NotFound+) to the Rack
+  # status symbol they render (e.g. +:not_found+). Single source of truth for
+  # formatter error helpers and the Minitest/RSpec status assertions.
+  #
+  # Extended into ActionFigure, so the public API is ActionFigure.error_statuses
+  # and ActionFigure.register_error.
+  module ErrorRegistry
+    # Built-in error statuses. Domain-owned 4xx only — no 5xx ships built-in.
+    DEFAULTS = {
+      UnprocessableContent: :unprocessable_content,
+      NotFound: :not_found,
+      Forbidden: :forbidden,
+      Conflict: :conflict,
+      PaymentRequired: :payment_required,
+      Gone: :gone,
+      Locked: :locked,
+      UnavailableForLegalReasons: :unavailable_for_legal_reasons
+    }.freeze
+
+    # Live module holding one generated helper per registered error status.
+    # ActionFigure::Formatter includes it, so the helpers reach every formatter
+    # module and every composed format module through method lookup — including
+    # classes that included a format module before a late +register_error+ call.
+    # A helper hand-defined on a formatter shadows the generated one, because
+    # the formatter sits ahead of this module in the ancestor chain.
+    module Helpers; end
+
+    def self.define_helper(name, status_symbol)
+      Helpers.define_method(name) do |errors: nil, **extras|
+        error_response(errors: errors, status: status_symbol, **extras)
+      end
+    end
+
+    DEFAULTS.each { |name, status| define_helper(name, status) }
+
+    # Populates the registry when ErrorRegistry is extended (at gem load,
+    # single-threaded), so no lazy initialization races with reader threads.
+    def self.extended(base)
+      registry = Concurrent::Map.new
+      DEFAULTS.each { |name, status| registry[name] = status }
+      base.instance_variable_set(:@error_status_registry, registry)
+    end
+
+    # Statuses Rack itself doesn't map on every supported version:
+    # Rack < 3.1 knows 422 only as :unprocessable_entity, Rack >= 3.1 only as
+    # :unprocessable_content. Accept both everywhere.
+    STATUS_CODE_FALLBACKS = { unprocessable_content: 422, unprocessable_entity: 422 }.freeze
+
+    # A plain-Hash copy of the current registry (built-ins plus any registered).
+    def error_statuses
+      error_status_registry.each_pair.to_h
+    end
+
+    # Resolves a Rack-style status symbol to its numeric HTTP status code,
+    # raising ArgumentError for symbols no supported Rack version knows.
+    # Single resolution point for formatters and register_error validation.
+    def status_code_for(status_symbol)
+      Rack::Utils::SYMBOL_TO_STATUS_CODE[status_symbol] ||
+        STATUS_CODE_FALLBACKS[status_symbol] ||
+        raise(ArgumentError, "#{status_symbol.inspect} is not a known HTTP status symbol")
+    end
+
+    # Registers an additional error status. Add-only: does not remove or override.
+    # Defines the generated helper on the live Helpers module (so it appears on
+    # every formatter and already-included action class immediately) and patches
+    # already-loaded test adapters.
+    def register_error(name, status_symbol)
+      name = name.to_sym
+      status_symbol = status_symbol.to_sym
+      validate_registration!(name, status_symbol)
+
+      existing = error_status_registry.put_if_absent(name, status_symbol)
+      if existing && existing != status_symbol
+        raise ArgumentError,
+              "Error status #{name.inspect} is already registered as #{existing.inspect}; " \
+              "register_error is add-only and cannot override it"
+      end
+      return name if existing
+
+      ErrorRegistry.define_helper(name, status_symbol)
+      ActionFigure::Testing.define_error_helper(name, status_symbol) if defined?(ActionFigure::Testing)
+      name
+    end
+
+    private
+
+    attr_reader :error_status_registry
+
+    # Rejects reserved helper names and unknown status symbols up front, so a
+    # bad registration fails at boot instead of at render time.
+    def validate_registration!(name, status_symbol)
+      reserved = Formatter::REQUIRED_METHODS + [:NoContent]
+      if reserved.include?(name)
+        raise ArgumentError,
+              "#{name.inspect} is reserved by the formatter contract and cannot be " \
+              "registered as an error status"
+      end
+
+      status_code_for(status_symbol)
+    end
+  end
+end

data/lib/action_figure/formatter.rb

@@ -1,13 +1,20 @@
 # frozen_string_literal: true
 
+require_relative "error_registry"
+
 module ActionFigure
   # Base module for ActionFigure response formatters.
-  # Include this in your formatter module to get a NoContent default
-  # and to signal that your module implements the formatter interface.
+  # Include this in your formatter module to get a NoContent default, the
+  # generated named error helpers (NotFound, Conflict, and every registered
+  # status), and to signal that your module implements the formatter interface.
   module Formatter
-    # Response helper names every formatter must define (+NoContent+ lives on +Formatter+, not required here).
-    # Update every built-in formatter when you extend this list; +register_formatter+ validates against it at load time.
-    REQUIRED_METHODS = %i[Ok Created Accepted UnprocessableContent NotFound Forbidden Conflict PaymentRequired].freeze
+    include ErrorRegistry::Helpers
+
+    # Structural methods every formatter must define: the three success helpers plus
+    # the single error_response. Named error helpers are generated from
+    # ActionFigure.error_statuses onto ErrorRegistry::Helpers (included here),
+    # so they are NOT a per-formatter obligation.
+    REQUIRED_METHODS = %i[Ok Created Accepted error_response].freeze
 
     def NoContent
       { status: :no_content }

data/lib/action_figure/formatters/default.rb

@@ -25,24 +25,8 @@ module ActionFigure
         { json: body, status: :accepted }
       end
 
-      def UnprocessableContent(errors:)
-        { json: { errors: errors }, status: :unprocessable_content }
-      end
-
-      def NotFound(errors:)
-        { json: { errors: errors }, status: :not_found }
-      end
-
-      def Forbidden(errors:)
-        { json: { errors: errors }, status: :forbidden }
-      end
-
-      def Conflict(errors:)
-        { json: { errors: errors }, status: :conflict }
-      end
-
-      def PaymentRequired(errors:)
-        { json: { errors: errors }, status: :payment_required }
+      def error_response(errors:, status:)
+        { json: { errors: errors }, status: status }
       end
     end
   end

data/lib/action_figure/formatters/jsend.rb

@@ -25,24 +25,8 @@ module ActionFigure
         { json: body, status: :accepted }
       end
 
-      def UnprocessableContent(errors:)
-        { json: { status: "fail", data: errors }, status: :unprocessable_content }
-      end
-
-      def NotFound(errors:)
-        { json: { status: "fail", data: errors }, status: :not_found }
-      end
-
-      def Forbidden(errors:)
-        { json: { status: "fail", data: errors }, status: :forbidden }
-      end
-
-      def Conflict(errors:)
-        { json: { status: "fail", data: errors }, status: :conflict }
-      end
-
-      def PaymentRequired(errors:)
-        { json: { status: "fail", data: errors }, status: :payment_required }
+      def error_response(errors:, status:)
+        { json: { status: "fail", data: errors }, status: status }
       end
     end
   end

data/lib/action_figure/formatters/json_api.rb

@@ -26,24 +26,9 @@ module ActionFigure
         { json: body, status: :accepted }
       end
 
-      def UnprocessableContent(errors:)
-        { json: { errors: convert_errors(errors, "422") }, status: :unprocessable_content }
-      end
-
-      def NotFound(errors:)
-        { json: { errors: convert_errors(errors, "404") }, status: :not_found }
-      end
-
-      def Forbidden(errors:)
-        { json: { errors: convert_errors(errors, "403") }, status: :forbidden }
-      end
-
-      def Conflict(errors:)
-        { json: { errors: convert_errors(errors, "409") }, status: :conflict }
-      end
-
-      def PaymentRequired(errors:)
-        { json: { errors: convert_errors(errors, "402") }, status: :payment_required }
+      def error_response(errors:, status:)
+        code = ActionFigure.status_code_for(status).to_s
+        { json: { errors: convert_errors(errors, code) }, status: status }
       end
 
       private