action_figure 0.5.0 → 0.6.2

data/docs/response-formatters.md

@@ -47,7 +47,7 @@ end
 
 ## Response Helpers
 
-Every formatter implements the same seven response helpers. Six return a hash with `:json` and `:status` keys. `NoContent` returns only `:status`.
+Every formatter implements the same nine response helpers. Eight return a hash with `:json` and `:status` keys. `NoContent` returns only `:status`.
 
 | Helper                          | HTTP Status              | When to Use                                      |
 |---------------------------------|--------------------------|--------------------------------------------------|
@@ -55,9 +55,11 @@ Every formatter implements the same seven response helpers. Six return a hash wi
 | `Created(resource:, meta: nil)` | `201 Created`            | Successful resource creation                     |
 | `Accepted(resource: nil, meta: nil)` | `202 Accepted`      | Request accepted for background processing       |
 | `NoContent()`                   | `204 No Content`         | Successful delete or action with no response body|
-| `UnprocessableContent(errors:)` | `422 Unprocessable Content` | Validation failures                           |
-| `NotFound(errors:)`             | `404 Not Found`          | Resource not found                               |
+| `PaymentRequired(errors:)`      | `402 Payment Required`   | Business billing or quota constraint             |
 | `Forbidden(errors:)`            | `403 Forbidden`          | Authorization failure                            |
+| `NotFound(errors:)`             | `404 Not Found`          | Resource not found                               |
+| `Conflict(errors:)`             | `409 Conflict`           | Resource state conflict or duplicate             |
+| `UnprocessableContent(errors:)` | `422 Unprocessable Content` | Validation failures                           |
 
 `NoContent` is shared across all formatters and is defined in the base `Formatter` module. It returns `{ status: :no_content }` with no JSON body.
 
@@ -227,6 +229,41 @@ end
 }
 ```
 
+**`Conflict`:**
+
+```ruby
+def call(params:)
+  return Conflict(errors: { email: ["already registered"] }) if User.exists?(email: params[:email])
+  user = User.create(params)
+  Created(resource: user)
+end
+```
+
+```json
+{
+  "errors": {
+    "email": ["already registered"]
+  }
+}
+```
+
+**`PaymentRequired`:**
+
+```ruby
+def call(params:, current_user:)
+  return PaymentRequired(errors: { base: ["subscription expired"] }) if current_user.subscription_expired?
+  Ok(resource: Dashboard.for(current_user))
+end
+```
+
+```json
+{
+  "errors": {
+    "base": ["subscription expired"]
+  }
+}
+```
+
 ## JSend Format
 
 The JSend formatter wraps responses in the [JSend specification](https://github.com/omniti-labs/jsend) envelope.
@@ -382,6 +419,43 @@ end
 }
 ```
 
+**`Conflict`:**
+
+```ruby
+def call(params:)
+  return Conflict(errors: { email: ["already registered"] }) if User.exists?(email: params[:email])
+  user = User.create(params)
+  Created(resource: user)
+end
+```
+
+```json
+{
+  "status": "fail",
+  "data": {
+    "email": ["already registered"]
+  }
+}
+```
+
+**`PaymentRequired`:**
+
+```ruby
+def call(params:, current_user:)
+  return PaymentRequired(errors: { base: ["subscription expired"] }) if current_user.subscription_expired?
+  Ok(resource: Dashboard.for(current_user))
+end
+```
+
+```json
+{
+  "status": "fail",
+  "data": {
+    "base": ["subscription expired"]
+  }
+}
+```
+
 ## Wrapped Format
 
 The Wrapped formatter places every response in a uniform `{ data:, errors:, status: }` envelope. Success responses use `"status": "success"` and failure responses use `"status": "error"`.
@@ -543,6 +617,45 @@ end
 }
 ```
 
+**`Conflict`:**
+
+```ruby
+def call(params:)
+  return Conflict(errors: { email: ["already registered"] }) if User.exists?(email: params[:email])
+  user = User.create(params)
+  Created(resource: user)
+end
+```
+
+```json
+{
+  "data": null,
+  "errors": {
+    "email": ["already registered"]
+  },
+  "status": "error"
+}
+```
+
+**`PaymentRequired`:**
+
+```ruby
+def call(params:, current_user:)
+  return PaymentRequired(errors: { base: ["subscription expired"] }) if current_user.subscription_expired?
+  Ok(resource: Dashboard.for(current_user))
+end
+```
+
+```json
+{
+  "data": null,
+  "errors": {
+    "base": ["subscription expired"]
+  },
+  "status": "error"
+}
+```
+
 ## JSON:API Format
 
 The JSON:API formatter structures responses according to the [JSON:API specification](https://jsonapi.org/).
@@ -739,6 +852,49 @@ end
 }
 ```
 
+**`Conflict`:**
+
+```ruby
+def call(params:)
+  return Conflict(errors: { email: ["already registered"] }) if User.exists?(email: params[:email])
+  user = User.create(params)
+  Created(resource: user)
+end
+```
+
+```json
+{
+  "errors": [
+    {
+      "status": "409",
+      "detail": "already registered",
+      "source": { "pointer": "/data/attributes/email" }
+    }
+  ]
+}
+```
+
+**`PaymentRequired`:**
+
+```ruby
+def call(params:, current_user:)
+  return PaymentRequired(errors: { base: ["subscription expired"] }) if current_user.subscription_expired?
+  Ok(resource: Dashboard.for(current_user))
+end
+```
+
+```json
+{
+  "errors": [
+    {
+      "status": "402",
+      "detail": "subscription expired",
+      "source": { "pointer": "/data" }
+    }
+  ]
+}
+```
+
 ## ActiveRecord Serialization (JSON:API)
 
 The JSON:API formatter includes automatic serialization for ActiveRecord objects via the `Resource` class.

data/docs/status-codes.md

@@ -0,0 +1,35 @@
+# HTTP 4xx Status Codes
+
+Rows in **bold** are status codes with built-in formatter methods — action classes can return these directly via helpers like `NotFound(errors:)` or `Conflict(errors:)`. All other 4xx codes are handled outside action classes by the perimeter (middleware, router, Rack, or infrastructure).
+
+| Status | Name                             | Category  | Responsibility  | Description / Logic Example                                          |
+|--------|----------------------------------|-----------|-----------------|----------------------------------------------------------------------|
+| 400    | Bad Request                      | Perimeter | Controller/Rack | Malformed syntax or missing top-level structure.                     |
+| 401    | Unauthorized                     | Perimeter | Middleware/Auth  | Authentication failed or missing credentials.                        |
+| **402** | **Payment Required**            | **Domain** | **Action Class** | **Business state: "Subscription overdue" or "Quota exceeded."**     |
+| **403** | **Forbidden**                   | **Domain** | **Action Class** | **Authenticated, but lacks permissions for this specific task.**    |
+| **404** | **Not Found**                   | **Domain** | **Action Class** | **The requested resource ID does not exist in the database.**       |
+| 405    | Method Not Allowed               | Perimeter | Rails Router     | Sending a POST to a GET route.                                       |
+| 406    | Not Acceptable                   | Perimeter | Controller       | Client requested a format (e.g., XML) the server won't provide.     |
+| 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).                  |
+| 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.                   |
+| 414    | URI Too Long                     | Perimeter | Server/Nginx     | The URL is too long for the server to process.                       |
+| 415    | Unsupported Media Type           | Perimeter | Controller       | Sending text/plain instead of application/json.                      |
+| 416    | Range Not Satisfiable            | Perimeter | Server/Rack      | Invalid Range header (usually for file downloads).                   |
+| 417    | Expectation Failed               | Perimeter | Server           | The server can't meet the Expect header requirements.                |
+| 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.                   |
+| 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.                |

data/docs/testing.md

@@ -33,6 +33,10 @@ end
 | `assert_UnprocessableContent(result)` | `:unprocessable_content` |
 | `assert_NotFound(result)`             | `:not_found`             |
 | `assert_Forbidden(result)`            | `:forbidden`             |
+| `assert_Conflict(result)`             | `:conflict`              |
+| `assert_PaymentRequired(result)`      | `:payment_required`      |
+
+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.
 
 All assertions accept an optional second argument for a custom failure message:
 
@@ -59,6 +63,8 @@ Require the helper in your spec support file. No `include` is needed -- the matc
 require "action_figure/testing/rspec"
 ```
 
+**Load order:** require this library **after** RSpec Core and expectations load (usual practice: append it toward the **bottom** of `spec/spec_helper.rb`, after any `require "rails_helper"` / `RSpec.configure` boilerplate from your app). ActionFigure pulls in **`rspec/matchers`**; minimalist scripts without the full **`rspec` CLI shim** must **`require "rspec/expectations"`** (and typically **`require "rspec/core"`**) *before* this file.
+
 ### Matchers
 
 | Matcher                   | Expected status          |
@@ -70,6 +76,20 @@ require "action_figure/testing/rspec"
 | `be_UnprocessableContent` | `:unprocessable_content` |
 | `be_NotFound`             | `:not_found`             |
 | `be_Forbidden`            | `:forbidden`             |
+| `be_Conflict`             | `:conflict`              |
+| `be_PaymentRequired`      | `:payment_required`      |
+| `have_action_json`        | `result[:json]` matches `a_hash_including(fragment)` |
+
+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):
+
+```ruby
+expect(result).to be_Ok
+expect(result).to have_action_json(status: "success")
+expect(result).to have_action_json(
+  status: "success",
+  data: a_hash_including(name: "Jane")
+)
+```
 
 Matchers support negation:
 
@@ -101,7 +121,7 @@ class Users::CreateActionTest < Minitest::Test
   include ActionFigure::Testing::Minitest
 
   def test_creates_a_user
-    result = Users::CreateAction.call(params: { email: "jane@example.com", name: "Jane" })
+    result = Users::CreateAction.create(params: { email: "jane@example.com", name: "Jane" })
 
     assert_Ok(result)
     assert_equal "jane@example.com", result[:json][:data][:email]
@@ -119,7 +139,7 @@ class Users::CreateActionTest < Minitest::Test
   include ActionFigure::Testing::Minitest
 
   def test_rejects_missing_email
-    result = Users::CreateAction.call(params: { name: "Jane" })
+    result = Users::CreateAction.create(params: { name: "Jane" })
 
     assert_UnprocessableContent(result)
     assert_includes result[:json][:data][:email], "is missing"
@@ -137,7 +157,7 @@ class Posts::CreateActionTest < Minitest::Test
 
   def test_creates_a_post_for_the_current_user
     user = users(:jane)
-    result = Posts::CreateAction.call(params: { title: "Hello", body: "World" }, current_user: user)
+    result = Posts::CreateAction.create(params: { title: "Hello", body: "World" }, current_user: user)
 
     assert_Created(result)
     assert_equal user.id, result[:json][:data][:author_id]
@@ -145,9 +165,9 @@ class Posts::CreateActionTest < Minitest::Test
 end
 ```
 
-### Testing a Custom Entry Point
+### Testing an Action with a Named Method
 
-When an action defines a custom class method (e.g., `.search`) instead of the default `.call`, call it by that name:
+Call the action using its discovered method name:
 
 ```ruby
 class Products::SearchActionTest < Minitest::Test
@@ -156,8 +176,6 @@ class Products::SearchActionTest < Minitest::Test
   # class SearchAction
   #   include ActionFigure[:jsend]
   #
-  #   entry_point :search
-  #
   #   params_schema do
   #     required(:query).filled(:string)
   #   end
@@ -187,14 +205,14 @@ class Sessions::DestroyActionTest < Minitest::Test
   # class Sessions::DestroyAction
   #   include ActionFigure[:jsend]
   #
-  #   def call(session:)
+  #   def destroy(session:)
   #     session.destroy!
   #     NoContent()
   #   end
   # end
   def test_destroys_the_session
     session = sessions(:active)
-    result = Sessions::DestroyAction.call(session: session)
+    result = Sessions::DestroyAction.destroy(session: session)
 
     assert_NoContent(result)
   end
@@ -224,7 +242,7 @@ result.failure?      # => true
 result.errors.to_h   # => { email: ["must be filled"] }
 ```
 
-This runs both the schema and any `rules` defined on the action -- the same validation pipeline that `.call` uses, without the side effects.
+This runs both the schema and any `rules` defined on the action -- the same validation pipeline that the class-level trigger uses, without the side effects.
 
 Actions that do not define a `params_schema` return `nil` from `.contract`.
 

data/docs/validation.md

@@ -9,7 +9,7 @@ The two layers are:
 1. **`params_schema`** -- structural validation and type coercion (powered by dry-schema)
 2. **`rules`** -- validation rules that run only after the schema passes
 
-If `params:` is not passed to the action at all, validation is skipped entirely and `#call` is invoked directly. If `params:` is passed but no `params_schema` is defined, an `ArgumentError` is raised immediately.
+If no `params_schema` is defined, `params:` passes through to your `#call` method as-is — no validation, no coercion, no stripping of extra keys. This lets you rely on upstream validation (e.g., Rack middleware like `committee`) while still using ActionFigure for orchestration and response formatting.
 
 ---
 
@@ -17,6 +17,8 @@ If `params:` is not passed to the action at all, validation is skipped entirely
 
 `params_schema` accepts a block written in the [dry-schema](https://dry-rb.org/gems/dry-schema/) DSL. It defines the shape of your input: which keys are allowed, which are required, and what types they must be.
 
+Each action calls **`params_schema` at most once** — a second call raises **`ArgumentError`**.
+
 ```ruby
 class Users::CreateAction
   include ActionFigure[:jsend]
@@ -100,6 +102,8 @@ end
   ArgumentError: rules requires params_schema to be defined
   ```
 
+- `params_schema` **may only be called once per action class**. Calling it again raises **`ArgumentError`**, so your schema cannot be replaced in a way that could silently confuse or strand an existing **`rules`** block.
+
 - Inside a rule block, access validated values with `values[:field]`.
 - Add an error to a specific field with `key(:field).failure("message")`, or `key.failure("message")` when the rule is scoped to a single field via `rule(:field)`.
 - Multiple rules can target the same field. All rules run even if earlier ones fail -- errors accumulate.

data/lib/action_figure/core.rb

@@ -36,13 +36,18 @@ module ActionFigure
       end
     end
 
-    # DSL class methods extended into action classes: params_schema, rules, entry_point, call.
+    # DSL class methods extended into action classes: params_schema, rules, entry_point.
     #
     # Note: ActionFigure does not support class inheritance. +params_schema+, +rules+, and
     # +entry_point+ store state in class-level instance variables that are not inherited by
     # subclasses. Define each action class independently.
     module ClassMethods
       def params_schema(&block)
+        if @params_schema_block
+          raise ArgumentError,
+                "params_schema already defined — each action class may declare only one schema"
+        end
+
         @params_schema_block = block
         @contract = nil
       end
@@ -64,6 +69,7 @@ module ActionFigure
                 "each action class may declare only one entry point"
         end
 
+        @explicit_entry_point = true
         @entry_point_name = name
         singleton_class.define_method(name) do |**kwargs|
           notify { new.validated_call(**kwargs) }
@@ -78,14 +84,6 @@ module ActionFigure
         value == :_unset ? @api_version : (@api_version = value)
       end
 
-      def call(**)
-        if @entry_point_name
-          raise NoMethodError, "undefined method 'call' for #{self} (use '#{@entry_point_name}' instead)"
-        end
-
-        notify { new.validated_call(**) }
-      end
-
       def contract
         return nil unless @params_schema_block
 
@@ -99,6 +97,38 @@ module ActionFigure
         yield
       end
 
+      def method_added(name)
+        disallow_action_initialize(name)
+
+        return if @explicit_entry_point || !public_method_defined?(name)
+        return unless instance_method(name).owner == self
+
+        if @entry_point_name
+          raise IndeterminateEntryPointError,
+                "Multiple public methods defined in #{self}: " \
+                ":#{@entry_point_name} and :#{name}. " \
+                "Either make one private or declare " \
+                "`entry_point :#{@entry_point_name}` to disambiguate."
+        end
+
+        @entry_point_name = name
+        singleton_class.define_method(name) do |**kwargs|
+          notify { new.validated_call(**kwargs) }
+        end
+      ensure
+        super
+      end
+
+      def disallow_action_initialize(method_name)
+        return unless method_name == :initialize
+        return unless instance_method(:initialize).owner == self
+
+        raise InitializationNotSupportedError,
+              "#{self} must not define initialize — ActionFigure invokes new with no " \
+              "arguments. Pass dependencies via the entry method's keyword arguments " \
+              "or use class-level collaborators."
+      end
+
       def build_contract
         schema_block = @params_schema_block
         rules_block = @rules_block
@@ -115,7 +145,7 @@ module ActionFigure
     end
 
     def entry_point_name
-      self.class.entry_point_name || :call
+      self.class.entry_point_name
     end
 
     def contract
@@ -123,12 +153,12 @@ module ActionFigure
     end
 
     def validated_call(**kwargs)
-      raise ArgumentError, "params: passed but no params_schema defined" if kwargs.key?(:params) && !contract
+      kwargs = normalize_params(kwargs)
 
-      if kwargs.key?(:params)
-        call_with_params(**kwargs)
+      if contract && kwargs.key?(:params)
+        validate_and_call(**kwargs)
       else
-        call_without_params(**kwargs)
+        public_send(entry_point_name, **kwargs)
       end
     end
 
@@ -138,7 +168,10 @@ module ActionFigure
       private
 
       def notify
-        payload = { action: name }
+        payload = {
+          action: name,
+          entry_point: entry_point_name
+        }
         ActiveSupport::Notifications.instrument("process.action_figure", payload) do
           result = yield
           payload[:status] = result[:status]
@@ -149,32 +182,54 @@ module ActionFigure
 
     private
 
-    def call_with_params(**kwargs)
-      raw_params = kwargs[:params]
-      raw_params = raw_params.to_unsafe_h if raw_params.respond_to?(:to_unsafe_h)
+    def normalize_params(kwargs)
+      return kwargs unless contract
+
+      raw = kwargs[:params]
+      return kwargs unless raw.respond_to?(:to_unsafe_h)
+
+      kwargs.merge(params: raw.to_unsafe_h)
+    end
 
-      result = contract.call(raw_params)
+    def validate_and_call(**kwargs)
+      result = contract.call(kwargs[:params])
 
       return UnprocessableContent(errors: result.errors.to_h) if result.failure?
 
-      extra_params_error = check_extra_params(raw_params, result)
+      extra_params_error = check_extra_params(kwargs[:params], result)
       return extra_params_error if extra_params_error
 
-      public_send(entry_point_name, **kwargs, params: result.to_h)
+      public_send(entry_point_name, **kwargs.except(:params), params: result.to_h)
     end
 
     def check_extra_params(raw_params, result)
       return unless ActionFigure.configuration.whiny_extra_params
 
-      extra_keys = raw_params.keys.map(&:to_sym) - result.to_h.keys
-      return if extra_keys.empty?
+      errors = find_extra_keys(raw_params, result.to_h)
+      return if errors.empty?
 
-      errors = extra_keys.to_h { |k| [k, ["is not allowed"]] }
       UnprocessableContent(errors: errors)
     end
 
-    def call_without_params(**)
-      public_send(entry_point_name, **)
+    def find_extra_keys(raw, validated, prefix = nil)
+      top_level = extra_keys_at_level(raw, validated, prefix)
+      nested = nested_extra_keys(raw, validated, prefix)
+      top_level.merge(nested)
+    end
+
+    def extra_keys_at_level(raw, validated, prefix)
+      (raw.keys.map(&:to_sym) - validated.keys).to_h do |k|
+        [prefix ? :"#{prefix}.#{k}" : k, ["is not allowed"]]
+      end
+    end
+
+    def nested_extra_keys(raw, validated, prefix)
+      validated.each_with_object({}) do |(key, value), errors|
+        next unless value.is_a?(Hash) && raw[key].is_a?(Hash)
+
+        nested_prefix = [prefix, key].compact.join(".")
+        errors.merge!(find_extra_keys(raw[key], value, nested_prefix))
+      end
     end
   end
 end

data/lib/action_figure/format_registry.rb

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
+require "concurrent/map"
+
 module ActionFigure
   # Provides formatter registration and lookup for ActionFigure.
   module FormatRegistry
     # Stores the mapping of format names to formatter modules.
     class Formats
       def initialize
-        @formats = {}
+        @formats = Concurrent::Map.new
       end
 
       def register_formatter(**formatters)
-        @formats.merge!(formatters)
+        formatters.each { |name, mod| @formats[name] = mod }
       end
 
       def fetch(name)

data/lib/action_figure/formatter.rb

@@ -5,7 +5,9 @@ module ActionFigure
   # Include this in your formatter module to get a NoContent default
   # and to signal that your module implements the formatter interface.
   module Formatter
-    REQUIRED_METHODS = %i[Ok Created Accepted UnprocessableContent NotFound Forbidden].freeze
+    # 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
 
     def NoContent
       { status: :no_content }

data/lib/action_figure/formatters/default.rb

@@ -3,23 +3,25 @@
 module ActionFigure
   module Formatters
     # Implements Rails-style response helpers for use in action classes.
-    # Resource is the top-level JSON on success; errors live under an "errors" key on failure.
+    # Success responses use a { data: } envelope; errors live under an "errors" key on failure.
     module Default
       include ActionFigure::Formatter
 
       def Ok(resource:, meta: nil)
-        body = meta ? { data: resource, meta: meta } : resource
+        body = { data: resource }
+        body[:meta] = meta if meta
         { json: body, status: :ok }
       end
 
       def Created(resource:, meta: nil)
-        body = meta ? { data: resource, meta: meta } : resource
+        body = { data: resource }
+        body[:meta] = meta if meta
         { json: body, status: :created }
       end
 
       def Accepted(resource: nil, meta: nil)
-        body = resource.nil? ? {} : resource
-        body = { data: body, meta: meta } if meta
+        body = { data: resource }
+        body[:meta] = meta if meta
         { json: body, status: :accepted }
       end
 
@@ -34,6 +36,14 @@ module ActionFigure
       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 }
+      end
     end
   end
 end

data/lib/action_figure/formatters/jsend.rb

@@ -36,6 +36,14 @@ module ActionFigure
       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 }
+      end
     end
   end
 end