action_figure 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2afc60d26a2b7f19aa7a5e8e1e438dba5f0400688c9dd0b5ec184f0307484366
-  data.tar.gz: 346713da33afd14d6ea9d7862fbd7e71030d116e467664d6c73f19397e9a54c0
+  metadata.gz: 6c29461ca24fe48d0143c6c861a738e37fa04fa9954b0fcc3336f8154dc16a30
+  data.tar.gz: 93e527838e129363aafbba74751660831a54084cb159571fa71f0b9ef11322fc
 SHA512:
-  metadata.gz: 2dba3a5b85d8f8bd55ebcfca08fb9eeedb508e2ff2d5f16cd8c971c0e3eb5586ab614922b341c90aaed4ad4e3607eefd71c7bd76e881592b45f5a1ac4688e9f8
-  data.tar.gz: 9a796394dc06f986ec4cbeef0e7e9cf3e3a9a80aaa15b51edb16201e89db815e86f8ccc3b816366543c7a8878327fd8f2be9fee11a4fbfe4adc47fade36e3879
+  metadata.gz: 311b1a051ee7caec1aece62143607ed2484720ab6a04398b66f091087a0febccacc91e1478c438bbca98b93d0d13cf57da6f12d8ae3caf47dd8bbb0b642c7994
+  data.tar.gz: 4bd0d145727af9f7373301ad26abc7b65a08041071c07317cf3fb88a818961be09e834de1b857a5256c6012b2965e0aa2bf1da24943cd2219689416d14be5a22

data/README.md

@@ -5,127 +5,27 @@ Fully-articulated controller actions.
 ---
 > #### Table of Contents
 > [Installation](#installation)<br>
-> [Quick Start](#quick-start)<br>
 > [How It Works](#how-it-works)<br>
 > [Features](#features)<br>
-> [Full Example](#full-example)<br>
+> [Quick Start](#quick-start)<br>
 > [Design Philosophy](#design-philosophy)<br>
 > [Requirements](#requirements)<br>
 > [License](#license)
 ---
 
-**ActionFigure** replaces gnarly controller method logic with explicit, purpose-driven operation classes. Each action validates its input, executes its logic, and returns a render-ready hash — making your controller action methods one-liners and behavior easily testable.
-
-## Installation
-
-Add to your Gemfile and `bundle install`:
-
-```ruby
-gem "action_figure"
-```
-
-## Quick Start
-
-**1. Start with what the action should do.**
-
-```ruby
-# spec/actions/users/create_action_spec.rb
-RSpec.describe Users::CreateAction do
-  it "creates a user with valid parameters" do
-    company = Company.create!(name: "Acme")
-
-    # Note: Extra keyword arguments like company: are injected as context alongside params:
-    result = Users::CreateAction.call(
-      params: { user: { name: "Tad", email: "tad@example.com" } },
-      company: company
-    )
-
-    # Results are render-ready hashes (JSend formatted in this case)
-    # => { json: { status: "success", data: { name: "Tad", ... } }, status: :created }
-    expect(result).to be_Created
-    expect(result[:json][:data]).to include("name" => "Tad", "email" => "tad@example.com")
-    expect(User.find_by(email: "tad@example.com")).to be_persisted
-  end
-
-  it "fails when name is missing" do
-    company = Company.create!(name: "Acme")
-    result = Users::CreateAction.call(
-      params: { user: { email: "tad@example.com" } },
-      company: company
-    )
-
-    # Validation failures short-circuit before #call executes
-    # => { json: { status: "fail", data: { user: { name: ["is missing"] } } },
-    #      status: :unprocessable_content }
-    expect(result).to be_UnprocessableContent
-    expect(result[:json][:data][:user][:name]).to include("is missing")
-    expect(User.find_by(email: "tad@example.com")).not_to be_persisted
-  end
-end
-```
-
-**2. Define the action class.**
-
-```ruby
-# app/actions/users/create_action.rb
-class Users::CreateAction
-  include ActionFigure[:jsend]
-
-  params_schema do
-    required(:user).hash do
-      required(:name).filled(:string)
-      required(:email).filled(:string)
-    end
-  end
-
-  def call(params:, company:)
-    user = company.users.create(params[:user])
-    return UnprocessableContent(errors: user.errors.messages) if user.errors.any?
-
-    Created(resource: user.as_json(only: %i[id name email]))
-  end
-end
-```
-
-**3. Call it from your controller.**
+**ActionFigure** extracts controller actions into classes that validate params, orchestrate work, and return render-ready responses. Your controller becomes:
 
 ```ruby
-class UsersController < ApplicationController
+class OrdersController < ApplicationController
   def create
-    render Users::CreateAction.call(params:, company: current_company)
+    render Orders::CreateAction.create(params:, current_user:)
   end
 end
 ```
 
-## How It Works
-
-Every action class has three responsibilities:
-
-1. **Check params** — `params_schema` validates structure and types, `rules` enforces validation rules. If either fails, the formatter returns an error response and `#call` is never invoked.
-2. **Orchestrate** — `#call` coordinates the work: creating records, calling service objects, enqueuing jobs, or anything else your operation requires. The action is the entry point, not necessarily where all the logic lives.
-3. **Return a formatted response** — response helpers like `Created(resource:)` and `NotFound(errors:)` return render-ready hashes that go straight to `render` in your controller.
-
-## Features
-
-| Feature | Description |
-|---------|-------------|
-| [Validation](docs/validation.md) | Two-layer validation powered by dry-validation: structural schemas with type coercion, plus validation rules. Includes cross-parameter helpers like `one_rule`, `all_rule`, and `implies_rule`. |
-| [Response Formatters](docs/response-formatters.md) | Four built-in formats: Default, JSend, JSON:API, and Wrapped. Each provides response helpers (`Ok`, `Created`, `NotFound`, etc.) that return render-ready hashes. |
-| [Custom Formatters](docs/custom-formatters.md) | Define your own response envelope by implementing the formatter interface. Registration validates your module at load time. |
-| [Actions](docs/actions.md) | Custom entry points (`entry_point :search`), context injection via keyword arguments, per-class API versioning, and no-params actions. |
-| [Configuration](docs/configuration.md) | Global defaults for response format, parameter strictness, and API version. All overridable per-class. |
-| [Notifications](docs/activesupport-notifications.md) | Opt-in `ActiveSupport::Notifications` events for every action call. Emits action class, outcome status, and duration on the `process.action_figure` event. |
-| [Testing](docs/testing.md) | Minitest assertions (`assert_Ok`, `assert_Created`, ...) and RSpec matchers (`be_Ok`, `be_Created`, ...) for expressive status checks. |
-| [Integration Patterns](docs/integration-patterns.md) | Recipes for serializers (Blueprinter, Alba, Oj Serializers), authorization (Pundit, CanCanCan), and pagination (cursor, Pagy). |
-
-## Full Example
-
-Here is a more complete action showing how validation, authorization, and response formatting work together.
-
-**The action class:**
+The action class owns everything that used to be scattered across the controller method, strong params, model callbacks, and ad-hoc response building:
 
 ```ruby
-# app/actions/orders/create_action.rb
 class Orders::CreateAction
   include ActionFigure[:wrapped]
 
@@ -142,7 +42,7 @@ class Orders::CreateAction
              "gift fields must be provided together or not at all")
   end
 
-  def call(params:, current_user:)
+  def create(params:, current_user:)
     if current_user.unpaid_balance?
       return Forbidden(errors: { base: ["unpaid balance on account"] })
     end
@@ -163,22 +63,9 @@ class Orders::CreateAction
 end
 ```
 
-**The controller:**
+Param validation, cross-field rules, authorization, error handling, and response formatting — all in one place, all testable without a request:
 
 ```ruby
-class OrdersController < ApplicationController
-  def create
-    render Orders::CreateAction.call(params:, current_user:)
-  end
-end
-```
-
-**Testing it:**
-
-```ruby
-# test/actions/orders/create_action_test.rb
-require "action_figure/testing/minitest"
-
 class Orders::CreateActionTest < Minitest::Test
   include ActionFigure::Testing::Minitest
 
@@ -186,20 +73,19 @@ class Orders::CreateActionTest < Minitest::Test
     user = User.create!(name: "Tad")
     item = Item.create!(name: "Widget", price: 29.00)
 
-    result = Orders::CreateAction.call(
+    result = Orders::CreateAction.create(
       params: { item_id: item.id, quantity: 2 },
       current_user: user
     )
 
     assert_Created(result)
     assert_equal item.id, result[:json][:data]["item_id"]
-    assert_equal 2, result[:json][:data]["quantity"]
   end
 
   def test_forbidden_with_unpaid_balance
-    user = User.create!(name: "Tud", balance: -1)
+    user = User.create!(name: "Tad", balance: -1)
 
-    result = Orders::CreateAction.call(
+    result = Orders::CreateAction.create(
       params: { item_id: 1, quantity: 1 },
       current_user: user
     )
@@ -211,7 +97,7 @@ class Orders::CreateActionTest < Minitest::Test
   def test_not_found_when_item_missing
     user = User.create!(name: "Tad")
 
-    result = Orders::CreateAction.call(
+    result = Orders::CreateAction.create(
       params: { item_id: 999, quantity: 1 },
       current_user: user
     )
@@ -220,49 +106,135 @@ class Orders::CreateActionTest < Minitest::Test
     assert_includes result[:json][:errors][:item_id], "item not found"
   end
 
-  def test_surfaces_model_validation_errors
+  def test_rejects_partial_gift_fields
     user = User.create!(name: "Tad")
-    item = Item.create!(name: "Widget", price: 29.00, stock: 0)
+    item = Item.create!(name: "Widget", price: 29.00)
 
-    result = Orders::CreateAction.call(
-      params: { item_id: item.id, quantity: 5 },
+    result = Orders::CreateAction.create(
+      params: { item_id: item.id, quantity: 1, gift_message: "Enjoy!" },
       current_user: user
     )
 
     assert_UnprocessableContent(result)
-    assert_includes result[:json][:errors][:quantity], "exceeds available stock"
+    assert_includes result[:json][:errors][:gift_message],
+                    "gift fields must be provided together or not at all"
   end
+end
+```
 
-  def test_rejects_partial_gift_fields
-    user = User.create!(name: "Tad")
-    item = Item.create!(name: "Widget", price: 29.00)
+This isn't for everybody. If your controllers are already thin, or you validate through OpenAPI middleware like [committee](https://github.com/interagent/committee), you probably don't need this. ActionFigure is for teams whose controller actions have grown into tangled mixes of param wrangling, authorization checks, error handling, and response building.
 
-    result = Orders::CreateAction.call(
-      params: { item_id: item.id, quantity: 1, gift_message: "Enjoy!" },
-      current_user: user
+## Installation
+
+Add to your Gemfile and `bundle install`:
+
+```ruby
+gem "action_figure"
+```
+
+## How It Works
+
+Every action class has three responsibilities:
+
+1. **Check params** (optional) — when a `params_schema` is defined, it validates structure and types; `rules` enforces validation rules. If either fails, the formatter returns an error response and your action method is never invoked. Actions without a schema receive `params:` as-is.
+2. **Orchestrate** — your action method coordinates the work: creating records, calling service objects, enqueuing jobs, or anything else the action requires. The action is the entry point, not necessarily where all the logic lives.
+3. **Return a formatted response** — response helpers like `Created(resource:)` and `NotFound(errors:)` return render-ready hashes that go straight to `render` in your controller.
+
+## Features
+
+| Feature | Description |
+|---------|-------------|
+| [Validation](docs/validation.md) | Two-layer validation powered by dry-validation: structural schemas with type coercion, plus validation rules. Includes cross-parameter helpers like `exclusive_rule`, `any_rule`, `one_rule`, and `all_rule`. |
+| [Response Formatters](docs/response-formatters.md) | Four built-in formats: Default, JSend, JSON:API, and Wrapped. Each provides response helpers (`Ok`, `Created`, `NotFound`, etc.) that return render-ready hashes. |
+| [Status Codes](docs/status-codes.md) | Which 4xx codes are domain concerns (handled by action classes) vs perimeter concerns (handled by middleware, router, or infrastructure). |
+| [Custom Formatters](docs/custom-formatters.md) | Define your own response envelope by implementing the formatter interface. Registration validates your module at load time. |
+| [Actions](docs/actions.md) | Automatic entry point discovery, context injection via keyword arguments, per-class API versioning, and `entry_point` for disambiguation. |
+| [Configuration](docs/configuration.md) | Global defaults for response format, parameter strictness, and API version. All overridable per-class. |
+| [Notifications](docs/activesupport-notifications.md) | Opt-in `ActiveSupport::Notifications` events for every action call. Emits action class, outcome status, and duration on the `process.action_figure` event. |
+| [Testing](docs/testing.md) | Minitest assertions (`assert_Ok`, `assert_Created`, ...) and RSpec matchers (`be_Ok`, `be_Created`, ...) for expressive status checks. |
+| [Integration Patterns](docs/integration-patterns.md) | Recipes for serializers (Blueprinter, Alba, Oj Serializers), authorization (Pundit, CanCanCan), and pagination (cursor, Pagy). |
+
+## Quick Start
+
+**1. Define the action class.**
+
+```ruby
+# app/actions/users/create_action.rb
+class Users::CreateAction
+  include ActionFigure[:jsend]
+
+  params_schema do
+    required(:user).hash do
+      required(:name).filled(:string)
+      required(:email).filled(:string)
+    end
+  end
+
+  def create(params:, company:)
+    user = company.users.create(params[:user])
+    return UnprocessableContent(errors: user.errors.messages) if user.errors.any?
+
+    Created(resource: user.as_json(only: %i[id name email]))
+  end
+end
+```
+
+**2. Call it from your controller.**
+
+```ruby
+class UsersController < ApplicationController
+  def create
+    render Users::CreateAction.create(params:, company: current_company)
+  end
+end
+```
+
+**3. Test it directly.**
+
+```ruby
+class Users::CreateActionTest < Minitest::Test
+  include ActionFigure::Testing::Minitest
+
+  def test_creates_a_user
+    company = Company.create!(name: "Acme")
+
+    result = Users::CreateAction.create(
+      params: { user: { name: "Tad", email: "tad@example.com" } },
+      company: company
+    )
+
+    assert_Created(result)
+    assert_equal "Tad", result[:json][:data]["name"]
+  end
+
+  def test_fails_when_name_is_missing
+    company = Company.create!(name: "Acme")
+
+    result = Users::CreateAction.create(
+      params: { user: { email: "tad@example.com" } },
+      company: company
     )
 
     assert_UnprocessableContent(result)
-    assert_includes result[:json][:errors][:gift_message],
-                    "gift fields must be provided together or not at all"
-    assert_includes result[:json][:errors][:gift_recipient_email],
-                    "gift fields must be provided together or not at all"
+    assert_includes result[:json][:data][:user][:name], "is missing"
   end
 end
 ```
 
 ## Design Philosophy
 
+Unlike general-purpose service object libraries, ActionFigure is scoped to controller actions — it validates params, runs your logic, and returns a hash you pass directly to `render`.
+
 - **Purpose over convention** — each class does one thing and names it clearly
 - **Explicit over implicit** — no magic method resolution, no inherited callbacks
-- **Operations own their lifecycle** — validation, execution, and response formatting live together
+- **Actions own their lifecycle** — validation, execution, and response formatting live together
 - **Controllers become boring** — one-line `render` calls that delegate to action classes
-- **Models and Controllers stay thin** — business logic moves to purpose-built operations
+- **Models and Controllers stay thin** — business logic moves to purpose-built action classes
 
 ## Requirements
 
 - Ruby >= 3.2
-- [dry-validation](https://dry-rb.org/gems/dry-validation/) ~> 1.10
+- [dry-validation](https://dry-rb.org/gems/dry-validation/) ~> 1.10 — ActionFigure uses dry-validation for schema validation because it's the best tool for the job. There's no dependency injection container, no monads, no functional pipeline. Just a focused layer for controller actions.
 - Rails is not required, but ActionFigure is designed for Rails controller patterns
 
 ## License

data/docs/actions.md

@@ -6,9 +6,9 @@ An ActionFigure action class is a single-purpose operation. Each class encapsula
 
 ---
 
-## The Default: `call`
+## Naming Your Action Method
 
-Every action class gets a `.call` class method when it includes ActionFigure. It instantiates the class, runs the validation pipeline (if `params:` is provided), and delegates to the instance-level `#call` method.
+ActionFigure auto-discovers your action method by name. Define one public instance method on your action class and ActionFigure registers it as the entry point -- no macro required:
 
 ```ruby
 class Users::CreateAction
@@ -21,7 +21,7 @@ class Users::CreateAction
     end
   end
 
-  def call(params:, company:, **)
+  def create(params:, company:, **)
     user = company.users.create(params[:user])
     return UnprocessableContent(errors: user.errors.messages) if user.errors.any?
 
@@ -30,21 +30,31 @@ class Users::CreateAction
 end
 ```
 
-Wire it into a controller by passing `params:` and any additional context:
+Wire it into a controller using the discovered method name:
 
 ```ruby
 class UsersController < ApplicationController
   def create
-    render Users::CreateAction.call(params:, company: current_company)
+    render Users::CreateAction.create(params:, company: current_company)
   end
 end
 ```
 
----
+### How it works
+
+ActionFigure uses a `method_added` hook to watch for public instance methods defined on the class. The first public method defined becomes the registered entry point and a matching class-level method is created for it. The full validation pipeline (`params_schema` and `rules`) still runs through the discovered entry point before your method is invoked.
 
-## Custom Entry Points
+### Disambiguation with `entry_point`
 
-Some actions have a name that reads better than `.call`. The `entry_point` macro declares an alternative class-level method name:
+If a class ends up with more than one public instance method, ActionFigure cannot determine which one to use and raises an `IndeterminantEntryPointError`:
+
+```
+ActionFigure::IndeterminantEntryPointError: Multiple public methods defined in Orders::SearchAction:
+:search and :format_results. Either make one private or declare
+`entry_point :search` to disambiguate.
+```
+
+Use the `entry_point` macro to resolve this:
 
 ```ruby
 class Orders::SearchAction
@@ -66,46 +76,34 @@ class Orders::SearchAction
     resource = orders.as_json(only: %i[id tracking_number status])
     Ok(resource:)
   end
-end
-```
 
-Call it from a controller using the declared name:
+  private
 
-```ruby
-class OrdersController < ApplicationController
-  def index
-    render Orders::SearchAction.search(params:, company: current_company)
+  def build_scope(company)
+    company.orders.active
   end
 end
 ```
 
-### How it works
-
-- The instance method must match the declared entry point name (`:search` declares `.search` and expects `#search`). If an entry point is defined, any instance-level `#call` method is ignored by the class-level entry point.
-- The full validation pipeline still runs through the custom entry point -- `params_schema` and `rules` are applied before your method is invoked.
-- Calling `.call` on a class that declares a custom entry point raises a `NoMethodError` with a helpful message:
-
-  ```
-  NoMethodError: undefined method 'call' for Orders::SearchAction (use 'search' instead)
-  ```
+Only one entry point per class is allowed. A second `entry_point` declaration raises an `ArgumentError`:
 
-- Only one entry point per class is allowed. A second `entry_point` declaration raises an `ArgumentError`:
-
-  ```
-  ArgumentError: entry_point already defined as 'search' — each action class may declare only one entry point
-  ```
+```
+ArgumentError: entry_point already defined as 'search' — each action class may declare only one entry point
+```
 
 ---
 
-## No-Params Actions
+## Actions Without a Schema
 
-Actions that don't need validated input simply omit `params_schema`. The validation pipeline is skipped entirely.
+Actions that omit `params_schema` skip the validation pipeline entirely. Any `params:` passed through are delivered to your method as-is — no coercion, no stripping, no validation.
+
+This is useful when validation is handled upstream (e.g., Rack middleware like `committee` validating against an OpenAPI spec) or when the action simply doesn't need params:
 
 ```ruby
 class HealthCheckAction
   include ActionFigure[:jsend]
 
-  def call
+  def check
     Ok(resource: { status: "healthy", time: Time.current })
   end
 end
@@ -114,17 +112,11 @@ end
 ```ruby
 class HealthController < ApplicationController
   def show
-    render HealthCheckAction.call
+    render HealthCheckAction.check
   end
 end
 ```
 
-If you accidentally pass `params:` to an action that has no schema, ActionFigure raises immediately:
-
-```
-ArgumentError: params: passed but no params_schema defined
-```
-
 ---
 
 ## Context Injection
@@ -142,7 +134,7 @@ class Users::CreateAction
     end
   end
 
-  def call(params:, company:, current_user:)
+  def create(params:, company:, current_user:)
     user = company.users.create(params[:user].merge(invited_by: current_user))
     return UnprocessableContent(errors: user.errors.messages) if user.errors.any?
 
@@ -154,7 +146,7 @@ end
 ```ruby
 class UsersController < ApplicationController
   def create
-    render Users::CreateAction.call(
+    render Users::CreateAction.create(
       params:,
       company: current_company,
       current_user: current_user
@@ -175,7 +167,7 @@ A simple index action needs no params and no schema:
 class Users::IndexAction
   include ActionFigure[:jsend]
 
-  def call(company:)
+  def index(company:)
     users = company.users.order(:name)
     Ok(resource: users.as_json(only: %i[id name email]))
   end
@@ -185,7 +177,7 @@ end
 ```ruby
 class UsersController < ApplicationController
   def index
-    render Users::IndexAction.call(company: current_company)
+    render Users::IndexAction.index(company: current_company)
   end
 end
 ```
@@ -200,7 +192,7 @@ class Users::ShowAction
     required(:id).filled(:integer)
   end
 
-  def call(params:, company:)
+  def show(params:, company:)
     user = company.users.find_by(id: params[:id])
     return NotFound(errors: { base: ["user not found"] }) unless user
 
@@ -212,7 +204,7 @@ end
 ```ruby
 class UsersController < ApplicationController
   def show
-    render Users::ShowAction.call(params:, company: current_company)
+    render Users::ShowAction.show(params:, company: current_company)
   end
 end
 ```
@@ -230,7 +222,7 @@ class Users::CreateAction
     end
   end
 
-  def call(params:, company:)
+  def create(params:, company:)
     user = company.users.create(params[:user])
     return UnprocessableContent(errors: user.errors.messages) unless user.persisted?
 
@@ -242,7 +234,7 @@ end
 ```ruby
 class UsersController < ApplicationController
   def create
-    render Users::CreateAction.call(params:, company: current_company)
+    render Users::CreateAction.create(params:, company: current_company)
   end
 end
 ```
@@ -261,7 +253,7 @@ class Users::UpdateAction
     end
   end
 
-  def call(params:, company:)
+  def update(params:, company:)
     user = company.users.find_by(id: params[:id])
     return NotFound(errors: { base: ["user not found"] }) unless user
 
@@ -276,7 +268,7 @@ end
 ```ruby
 class UsersController < ApplicationController
   def update
-    render Users::UpdateAction.call(params:, company: current_company)
+    render Users::UpdateAction.update(params:, company: current_company)
   end
 end
 ```
@@ -291,7 +283,7 @@ class Users::DestroyAction
     required(:id).filled(:integer)
   end
 
-  def call(params:, company:)
+  def destroy(params:, company:)
     user = company.users.find_by(id: params[:id])
     return NotFound(errors: { base: ["user not found"] }) unless user
 
@@ -304,7 +296,7 @@ end
 ```ruby
 class UsersController < ApplicationController
   def destroy
-    render Users::DestroyAction.call(params:, company: current_company)
+    render Users::DestroyAction.destroy(params:, company: current_company)
   end
 end
 ```
@@ -325,7 +317,7 @@ class Users::BulkInviteAction
     required(:emails).value(:array, min_size?: 1).each(:str?)
   end
 
-  def call(params:, company:)
+  def invite(params:, company:)
     result = BulkInviteService.call(emails: params[:emails], company: company)
     return UnprocessableContent(errors: result.errors) if result.failures?
 
@@ -337,7 +329,7 @@ end
 ```ruby
 class Users::InvitesController < ApplicationController
   def create
-    render Users::BulkInviteAction.call(params:, company: current_company)
+    render Users::BulkInviteAction.invite(params:, company: current_company)
   end
 end
 ```
@@ -356,7 +348,7 @@ class Reports::GenerateAction
     end
   end
 
-  def call(params:, current_user:)
+  def generate(params:, current_user:)
     result = ReportService.enqueue(params: params[:report], requested_by: current_user)
     return UnprocessableContent(errors: result.errors) if result.failed?
 
@@ -368,7 +360,7 @@ end
 ```ruby
 class ReportsController < ApplicationController
   def create
-    render Reports::GenerateAction.call(params:, current_user: current_user)
+    render Reports::GenerateAction.generate(params:, current_user: current_user)
   end
 end
 ```
@@ -379,7 +371,7 @@ File imports work the same way — receive the file, hand it off, translate the
 class Products::ImportAction
   include ActionFigure[:jsend]
 
-  def call(file:, company:)
+  def import(file:, company:)
     result = ProductImportService.call(file: file, company: company)
     return UnprocessableContent(errors: result.errors) if result.failed?
 
@@ -391,7 +383,7 @@ end
 ```ruby
 class Products::ImportsController < ApplicationController
   def create
-    render Products::ImportAction.call(file: params[:file], company: current_company)
+    render Products::ImportAction.import(file: params[:file], company: current_company)
   end
 end
 ```
@@ -415,7 +407,7 @@ class Users::CreateAction
     end
   end
 
-  def call(params:)
+  def create(params:)
     user = User.create(params[:user])
     return UnprocessableContent(errors: user.errors.messages) if user.errors.any?
 
@@ -435,7 +427,7 @@ Users::CreateAction.api_version  #=> "2.0"
 Inside an action instance, access it through the class:
 
 ```ruby
-def call(params:, **)
+def create(params:, **)
   if self.class.api_version == "2.0"
     # v2 behavior
   end