wayfarer 0.4.9 → 0.5.0

data/docs/guides/development.md

@@ -2,21 +2,11 @@
 
 ## Release Procedure
 
-1. Ensure `Wayfarer::VERSION` was bumped appropriately.
-2. Ensure the version in wayfarer.gemspec matches.
-3. Open a release Pull Request develop -> master branch
-4. Merge the Pull Request
-5. Publish RubyGem and git tag as follows:
-
-```
-git checkout master
-git pull origin master --rebase
-bundle exec rake build
-gem push build/wayfarer-*.gem
-bundle exec rake clean
-git tag <VERSION>
-git push origin <VERSION>
-```
+1. Bump versions:
+  * `Wayfarer::VERSION` in `lib/wayfarer.rb`
+  * RubyGem version in `wayfarer.gemspec`
+  * Run `bundle install` to regenerate `Gemfile.lock`
+2. Push to `master` or `develop` and run the manual `release` worflow
 
 ## Conventions and guidelines
 
@@ -27,10 +17,11 @@ git push origin <VERSION>
 
 ### Navigate the web along URL patterns
 
-URLs are less prone to change than served markup.
-One reason for this is that changes to a URL's path can have negative
-consequences for its page ranking in search engines. Websites naturally implement
-architectural URL patterns like REST or expose surrogate keys.
+URLs are less prone to change than served markup. There are also SEO
+incentives to keep their paths stable. Since websites naturally implement
+architectural URL patterns like REST on the application layer, URL structure
+reflects internal domain concepts necessarily, for which Wayfarer's URL-based
+routing is designed.
 
 ### Follow URLs verbatim as they appear in responses
 
@@ -49,17 +40,18 @@ is ephemeral.
 
 There are two core features that depend on Redis. First, per-batch acylicity is
 achieved by maintaining the set of processed URLs per batch in Redis.
-There's no option to follow links in a cyclic manner. Second, batch completion
-requires updating an integer value in Redis, and batch completion is a very
-useful feature, since most crawls should end eventually, and often you want to
-know when.
+There's no configuration option to follow links in a cyclic manner. Second,
+batch completion requires updating an integer value in Redis, and batch completion
+is a very useful feature, since most crawls should end eventually, and often you want
+to know when.
 
 ### No configuration files
 
-Wayfarer can be configured through `Wayfarer.config` only, because `Wayfarer.config`
-may contain Ruby objects that don't de/serialize well, such as `Proc`s or `Set`s.
+Wayfarer can be configured through `Wayfarer.config` in Ruby code only,
+because `Wayfarer.config` may contain Ruby objects that don't de/serialize well,
+such as `Proc`s or `Set`s.
 
-### Features out of scope
+### Other features that are out of scope
 
 Wayfarer won't provide:
 

data/docs/guides/handlers.md

@@ -1,6 +1,6 @@
 # Handlers
 
-Handlers are like [jobs](/jobs) but they don't inherit from `ActiveJob::Base`
+Handlers are like [jobs](jobs.md) but they don't inherit from `ActiveJob::Base`
 which is why they can't affect the message queue directly themselves.
 Instead, jobs and handlers can route tasks to other handlers. Handlers
 themselves have routes, but they can be bypassed.

data/docs/guides/jobs.md

@@ -1,14 +1,14 @@
 # Jobs
 
 Jobs are [Active Job](https://edgeguides.rubyonrails.org/active_job_basics.html)s
-that use a DSL to process [tasks](/guides/tasks) that they read from a message
+that use a DSL to process [tasks](tasks.md) that they read from a message
 queue.
 
 Instead of implementing Active Job's `#perform` method yourself, you declare
-[routes](../routing) to instance methods, like web applications route incoming
+[routes](routing.md) to instance methods, like web applications route incoming
 requests. Only URLs that match a route are retrieved and processed. All other
 URLs are considered successfully processed. The action has access to the
-retrieved [page](../pages), the [user agent](../user-agents) that retrieved the
+retrieved [page](pages.md), the [user agent](user_agents.md) that retrieved the
 page and the current task:
 
 ```ruby
@@ -47,7 +47,7 @@ Instead of a generated UUID, you can also set your own batch:
 DummyJob.crawl("https://example.com", batch: "my-batch")
 ```
 
-You can also use Wayfarer's [CLI](../cli) to enqueue a task:
+You can also use Wayfarer's [CLI](cli.md) to enqueue a task:
 
 ```sh
 wayfarer enqueue --batch my-batch DummyJob "https://example.com"
@@ -74,7 +74,7 @@ end
 
 ## Accessing the current task
 
-If the task's URL matched a [route](../routing), the URL is retrieved over the network,
+If the task's URL matched a [route](routing.md), the URL is retrieved over the network,
 and the method that was routed to is called. The task is available as `#task`:
 
 ```ruby
@@ -92,7 +92,7 @@ end
 
 ## Accessing the current page
 
-You have access to the retrieved [page](../pages):
+You have access to the retrieved [page](pages.md):
 
 ```ruby
 class DummyJob < ActiveJob::Base
@@ -184,7 +184,9 @@ Wayfarer relies on ActiveJob's [error handling methods](https://guides.rubyonrai
 * `retry_on` to retry jobs a number of times on certain errors:
 
     ```ruby
-    class DummyJob < Wayfarer::Base
+    class DummyJob < ActiveJob::Base
+      include Wayfarer::Base
+
       retry_on MyError, attempts: 3 do |job, error|
         # This block runs once all 3 attempts have failed
         # (1 initial attempt + 2 retries)
@@ -195,7 +197,9 @@ Wayfarer relies on ActiveJob's [error handling methods](https://guides.rubyonrai
 * `discard_on` to throw away jobs on certain errors:
 
     ```ruby
-    class DummyJob < Wayfarer::Base
+    class DummyJob < ActiveJob::Base
+      include Wayfarer::Base
+
       discard_on MyError do |job, error|
         # This block runs once and buries the job
       end
@@ -205,7 +209,7 @@ Wayfarer relies on ActiveJob's [error handling methods](https://guides.rubyonrai
 ## Recreating user agents on certain errors
 
 You can configure a list of exception classes upon which user agents
-get recreated (see [User agent API]()):
+get recreated (see [User agent API](user_agents.md)):
 
 ```ruby
 Wayfarer.config[:network][:renew_on] = [MyIrrecoverableError]

data/docs/guides/middleware.md

@@ -0,0 +1,134 @@
+# Middleware
+
+Wayfarer processes [tasks](tasks.md) through a middleware chain, an ordered
+pipeline of middleware classes. Each middleware receives a task, can modify it,
+and yields to the next middleware in the chain. If a middleware doesn't yield,
+the chain halts.
+
+A middleware is a class that implements a `call` method. It receives a `task`
+argument and must `yield` to continue the middleware chain.
+
+```ruby
+class MyCustomMiddleware
+  def call(task)
+    # Pre-processing: optionally set task metadata
+    task[:started_at] = Time.now.utc
+
+    # Yield to continue the chain (or not)
+    # Downstream middleware can access `task[:started_at]`
+    yield if block_given?
+
+    # Post-processing
+  end
+end
+```
+
+!!! info "Task metadata `#task[]=` is ephemeral"
+
+    Anything you assign to a task at runtime isn't serialized to the message
+    queue. For example in the case of a retry, no task metadata can be restored.
+
+A `DependencyGraph` manages the chain ordering by resolving `before:` and
+`after:` constraints between middlewares.
+
+## Default middleware chain
+
+Jobs that `#!ruby include Wayfarer::Base` get a default chain of 10 middlewares:
+
+1. `Redis`:  connects to Redis
+2. `UriParser`: parses the task URL
+3. `Normalize`: normalizes the URL
+4. `Dedup`: deduplicates tasks
+5. `BatchCompletion`: tracks batch progress
+6. `Stage`: collects staged URLs
+7. `Router`: matches the URL to an action
+8. `UserAgent`: retrieves the page
+9. `ContentType`: filters by Content-Type
+10. `Dispatch`: calls the routed action
+
+[Handlers](handlers.md) that `#!ruby include Wayfarer::Handler` get a shorter chain:
+
+1. `ContentType`
+2. `Router`
+3. `Dispatch`
+
+`#!ruby Wayfarer.config[:middleware][:base]` and `#!ruby
+Wayfarer.config[:middleware][:handler]` declare these defaults.
+
+## Adding middleware
+
+Use the `use` class method to add a middleware to a job's chain. You can
+declare ordering constraints with `before:` and `after:`:
+
+```ruby
+class MyJob < ActiveJob::Base
+  include Wayfarer::Base
+
+  use MyCustomMiddleware, after: [Wayfarer::Middleware::Router]
+end
+```
+
+!!! info "Auto-registration"
+
+    If you reference a middleware in `before:` or `after:` that hasn't been
+    explicitly added, it's registered automatically with no constraints.
+
+## Removing middleware
+
+Use `middleware.remove` to remove a middleware from the chain. All
+`before:` and `after:` references to the removed middleware are automatically
+cleaned up.
+
+```ruby
+class NoDedupJob < ActiveJob::Base
+  include Wayfarer::Base
+
+  self.middleware = middleware.remove(Wayfarer::Middleware::Dedup)
+end
+```
+
+## Replacing middleware
+
+Use `middleware.replace` to swap a middleware. The replacement inherits
+the exact same `before:` and `after:` constraints. The method updates all
+references to the old middleware in other entries to point to the replacement.
+
+```ruby
+class TestJob < ActiveJob::Base
+  include Wayfarer::Base
+
+  self.middleware = middleware.replace(
+    Wayfarer::Middleware::Redis,
+    MyInMemoryState
+  )
+end
+```
+
+!!! attention "`replace` inherits constraints"
+
+    If you need different constraints for the new middleware, use `remove`
+    followed by `add` instead.
+
+## The dependency graph
+
+The dependency graph is immutable. Every operation (`add`, `remove`, `replace`)
+returns a new instance which is why you always assign the result back:
+
+```ruby
+self.middleware = middleware.add(MyMiddleware, after: [Wayfarer::Middleware::Router])
+self.middleware = middleware.remove(Wayfarer::Middleware::Dedup)
+self.middleware = middleware.replace(OldMiddleware, NewMiddleware)
+```
+
+Circular dependencies raise a `#!ruby Wayfarer::Middleware::DependencyGraph::CyclicDependencyError`.
+
+## Modifying the global default
+
+You can modify the default middleware chain globally in an initializer. Any job
+class defined after this point uses the modified default:
+
+```ruby
+# config/initializers/wayfarer.rb
+Wayfarer.config[:middleware][:base] = Wayfarer.config[:middleware][:base]
+  .add(MyGlobalMiddleware, after: [Wayfarer::Middleware::Router])
+```

data/docs/guides/navigation.md

@@ -12,7 +12,9 @@ URL does not enqueue it immediately. Instead, the URL is added to a processing
 set first.
 
 ```ruby
-class DummyJob < Wayfarer::Base
+class DummyJob < ActiveJob::Base
+  include Wayfarer::Base
+
   route.to :index
 
   def index
@@ -35,7 +37,6 @@ def index
 end
 ```
 
-See also: [Performance: Stage less URLs](/guides/performance)
 
 !!! attention "Failing action methods do not enqueue tasks"
 
@@ -59,7 +60,9 @@ job's routes do not match the URL. When the task gets consumed, the URL does not
 get fetched and the action method not called.
 
 ```ruby
-class DummyJob < Wayfarer::Base
+class DummyJob < ActiveJob::Base
+  include Wayfarer::Base
+
   route do
     host "example.com", path: "/users/:user_id", to: :user
   end

data/docs/guides/networking/capybara.md

@@ -7,7 +7,9 @@ applications which adds a nice API that also works well for web scraping.
 Wayfarer.config[:network][:agent] = :capybara
 # Wayfarer.config[:capybara][:driver] = ...
 
-class DummyJob < Wayfarer::Worker
+class DummyJob < ActiveJob::Base
+  include Wayfarer::Base
+
   route.to :index
 
   def index

data/docs/guides/networking/custom_adapters.md

@@ -15,7 +15,7 @@ as they navigate to a URL
 Because spawning browser processes or instantiating HTTP clients is expensive,
 Wayfarer keeps user agents in a pool and reuses them across jobs. This means
 that browser state carries over between jobs, as each job checks out a previous
-job's user agent. When exceptions are raised, you must [handle them](/guides/jobs/#handling-errors).
+job's user agent. When exceptions are raised, you must [handle them](../jobs.md#handling-errors).
 
 Only on certain irrecoverable errors are individual user agents
 destroyed and recreated. For example when a browser process crashes, it is
@@ -62,7 +62,7 @@ exception classes upon which an instance of the user agent should get recreated
 ### Stateless interface
 
 In addition to the base interface, stateless user agents implement `#fetch(instance, url)`
-which fetches [pages](../pages) or indicates redirects:
+which fetches [pages](../pages.md) or indicates redirects:
 
 * `#create()` __(required)__
 * `#fetch(instance, url)` __(required)__: Called to retrieve a URL. Responses with a
@@ -93,7 +93,7 @@ instance callbacks:
 * `#create()` __(required)__
 * `#navigate(instance, url)` __(required)__: Navigates the user agent to the given URL.
 * `#live(instance)` __(required)__: Turns the current user agent state
-into a [page](../pages) by calling `success(url:, body:, status_code:, headers:)`.
+into a [page](../pages.md) by calling `success(url:, body:, status_code:, headers:)`.
 * `#destroy(instance)` (optional)
 * `::renew_on` (optional)
 

data/docs/guides/networking/ferrum.md

@@ -13,7 +13,9 @@ so:
 ```ruby
 Wayfarer.config[:network][:agent] = :ferrum
 
-class DummyWorker < Wayfarer::Worker
+class DummyJob < ActiveJob::Base
+  include Wayfarer::Base
+
   route.to :index
 
   def index

data/docs/guides/networking/http.md

@@ -6,10 +6,12 @@ also alongside automated browsers.
 ## Ad-hoc GET requests
 
 When automating browsers, it can be useful to additionally retrieve another page
-or even the current page over plain HTTP. Jobs can fetch URLs to [pages](/pages) with `#http`:
+or even the current page over plain HTTP. Jobs can fetch URLs to [pages](../pages.md) with `#http`:
 
 ```ruby
-class DummyJob < Wayfarer::Base
+class DummyJob < ActiveJob::Base
+  include Wayfarer::Base
+
   route.to :index
 
   def index

data/docs/guides/networking/selenium.md

@@ -9,7 +9,9 @@ so:
 ```ruby
 Wayfarer.config[:network][:agent] = :selenium
 
-class DummyWorker < Wayfarer::Worker
+class DummyJob < ActiveJob::Base
+  include Wayfarer::Base
+
   route.to :index
 
   def index
@@ -29,7 +31,9 @@ process.
     ```ruby
     Wayfarer.config[:network][:agent] = :selenium
 
-    class DummyJob < Wayfarer::Base
+    class DummyJob < ActiveJob::Base
+      include Wayfarer::Base
+
       route.to :index
 
       def index
@@ -39,7 +43,7 @@ process.
     end
     ```
 
-!!! note "Consider using [Ferrum](../ferrum) instead if Google Chrome suits your needs."
+!!! note "Consider using [Ferrum](ferrum.md) instead if Google Chrome suits your needs."
     Use Ferrum if you want to automate Google Chrome. It provides superior
     stability and a richer feature set compared to Selenium drivers.
 

data/docs/guides/pages.md

@@ -1,7 +1,7 @@
 # Pages
 
 A page is the immutable state of the contents behind a URL at a point in time,
-retrieved by a [user agent](user-agents.md). In other words, a page is an HTTP
+retrieved by a [user agent](user_agents.md). In other words, a page is an HTTP
 response, or the state of a remotely controlled browser.
 
 ```ruby
@@ -82,7 +82,9 @@ To get a page that reflects the current browser state, set the `#!ruby :live`
 keyword:
 
 ```ruby
-class DummyJob < Wayfarer::Worker
+class DummyJob < ActiveJob::Base
+  include Wayfarer::Base
+
   route.to :index
 
   def index

data/docs/guides/routing.md

@@ -1,19 +1,27 @@
 # Routing
 
 Wayfarer equips jobs with a declarative routing DSL that maps URLs to actions.
-Actions are instance methods denoted by symbols, or [handlers](/guides/handlers).
-[Pages](/guides/pages) are only retrieved from URLs which map to an action.
+Actions are instance methods denoted by symbols, or [handlers](handlers.md).
+[Pages](pages.md) are only retrieved from URLs which map to an action.
 
-!!! info "Routed URLs are normalized"
+!!! warning "Routed URLs are normalized"
 
-    By default, Wayfarer [applies some transformations to each URL](../tasks/#url-normalization) to bring it
-    into a canonical form. Routing happens based on this canonical form.
+    By default, Wayfarer [applies some transformations to each URL](tasks.md#url-normalization) to bring it
+    into a canonical form. __Routing happens based on this canonical form__,
+    not on the verbatim `task.url`.
 
-    You can always access a task's raw string as it was enqueued with `task.url`.
+    This means that for example a route declaration doesn't match the URL
+    `https://www.example.com`, since the URL's hostname is normalized to `example.com`.
+
+    ```ruby
+    route.host "www.example.com"
+    ```
+    You may need to pass the `wayfarer route` CLI sub-command the `-r FILE` option
+    and point to the file that configures `Wayfarer.config`.
 
 A job's route declarations equate to a predicate tree.
 When a URL is routed, the predicate tree is searched depth-first. If a
-matching leaf predicate is found, the found path's action is dispatched.
+matching leaf predicate is found, the downmost path's action is dispatched.
 You can extract data from URL path segments and query parameters and
 access it through `params` in jobs or handlers.
 
@@ -75,7 +83,7 @@ flowchart LR
   classDef unvisited    fill:#BDBDBD,stroke:#BDBDBD,color:#616161
 ```
 
-??? note "You can also visualise a job's routing tree with with the [`route` CLI subcommand](/guides/cli)"
+??? note "You can also visualise a job's routing tree with with the [`route` CLI subcommand](cli.md)"
 
     ```sh
     wayfarer route DummyJob -r dummy_job.rb http://localhost:9000/users/42/gallery

data/docs/guides/tasks.md

@@ -1,7 +1,7 @@
 # Tasks
 
 Tasks are the immutable units of work read from a message queue and processed by
-[jobs](/guides/jobs). A task consists of two strings:
+[jobs](jobs.md). A task consists of two strings:
 
 * The __URL__ to process
 * The __batch__ the task belongs to

data/docs/guides/tutorial.md

@@ -60,7 +60,79 @@ bundle exec wayfarer perform -r dummy_job.rb DummyJob https://example.com
 ```
 
 If you don't provide a batch, Wayfarer uses a generated UUID instead.
-We could have also used `DummyJob.crawl
+We could have also used `DummyJob.crawl("https://example.com")` in a Ruby script to enqueue the job programmatically.
 
+## Accessing page data
 
+The `page` method returns an object representing the HTTP response or browser state.
+Wayfarer automatically parses HTML, XML, and JSON responses.
 
+For HTML pages, `page.doc` returns a [Nokogiri](https://nokogiri.org/) document, and `page.meta` returns a [MetaInspector](https://github.com/jaimeiniesta/metainspector) object for easy access to metadata.
+
+Let's update `dummy_job.rb` to print the page title:
+
+```ruby title="dummy_job.rb"
+require "activejob"
+require "wayfarer"
+
+class DummyJob < ActiveJob::Base
+  include Wayfarer::Base
+
+  route.to :index
+
+  def index
+    puts "Title: #{page.doc.title.strip}"
+    puts "H1: #{page.doc.at('h1')&.text&.strip}"
+  end
+end
+```
+
+Running `perform` again will now show the title of the page you crawled.
+
+## Crawling and Staging
+
+To crawl more pages, we use the `stage` method. This adds new URLs to the current batch.
+Wayfarer handles deduplication, ensuring that we don't get stuck in loops processing the same URL multiple times within the same batch.
+
+We can use `page.meta.links.internal` to easily find all links on the current page that point to the same domain.
+
+Update `dummy_job.rb` to crawl recursively:
+
+```ruby title="dummy_job.rb"
+require "activejob"
+require "wayfarer"
+
+class DummyJob < ActiveJob::Base
+  include Wayfarer::Base
+
+  route.to :index
+
+  def index
+    puts "Crawling #{page.url}"
+    
+    # Stage all internal links found on the page
+    stage page.meta.links.internal
+  end
+end
+```
+
+## Executing the crawl
+
+The `wayfarer perform` command we used earlier only executes a single job. To run a full crawl where staged jobs are picked up and processed, we use `wayfarer execute`.
+
+This command starts an in-process async executor that will continue running until all jobs in the batch are complete.
+
+```sh
+bundle exec wayfarer execute -r dummy_job.rb DummyJob https://example.com
+```
+
+You will see output indicating that multiple pages are being crawled as Wayfarer follows the internal links.
+
+## Next steps
+
+Now that you have a basic crawler running, you can explore more advanced features:
+
+*   **[Routing](routing.md)**: Learn how to route different URLs to different methods or handler classes.
+*   **[Pages](pages.md)**: Dive deeper into the `Page` object and custom response parsers.
+*   **[Networking](user_agents.md)**: Configure Wayfarer to use Headless Chrome (via Ferrum or Selenium) for pages that require JavaScript.
+*   **[Configuration](configuration.md)**: Customize concurrency, user agents, and request headers.

data/docs/guides/user_agents.md

@@ -1,18 +1,18 @@
 # User agents
 
-User agents are used by [jobs](../jobs) to retrieve the contents behind a URL into a
-[page](../pages), for example a remotely controlled Firefox process or a Ruby HTTP client.
+User agents are used by [jobs](jobs.md) to retrieve the contents behind a URL into a
+[page](pages.md), for example a remotely controlled Firefox process or a Ruby HTTP client.
 
 User agents are kept in a connection pool and all user agents in the pool
 share the same type and configuration. You can add your own custom user agents by implementing
-the [user agent API](custom_user_agents.md).
+the [user agent API](networking/custom_adapters.md).
 
 Wayfarer comes with the following built-in user agents:
 
-* [`:http`](http.md) (default)
-* [`:ferrum`](ferrum.md) to automate Google Chrome
-* [`:selenium`](selenium.md) to automate a variety of browsers
-* [`:capybara`](capybara.md) to use Capybara sessions
+* [`:http`](networking/http.md) (default)
+* [`:ferrum`](networking/ferrum.md) to automate Google Chrome
+* [`:selenium`](networking/selenium.md) to automate a variety of browsers
+* [`:capybara`](networking/capybara.md) to use Capybara sessions
 
 Configure the user agent with the global configuration option:
 
@@ -35,7 +35,7 @@ class DummyJob < ActiveJob::Base
 end
 ```
 
-You can also implement [custom user agents](custom_user_agents.md) to support
+You can also implement [custom user agents](networking/custom_adapters.md) to support
 your own HTTP client or browser automation service/protocol.
 
 ### Ad-hoc HTTP requests
@@ -71,7 +71,7 @@ Wayfarer.config[:network][:http_headers] = { "User-Agent" => "MyCrawler" }
 
 Since user agents are expensive to create, especially in the case of browser
 processes,  Wayfarer keeps user agents within a connection pool. When a job
-performs and needs to retrieve the [page](../pages) for its task URL, an agent
+performs and needs to retrieve the [page](pages.md) for its task URL, an agent
 is checked out from the pool, and checked back in when the routed action method
 returns.
 
@@ -94,7 +94,7 @@ Wayfarer.config[:network][:pool][:size] = Sidekiq.options[:concurrency]
     The same browser session is used across jobs. This means that the browser
     is not closed between jobs, and that the browser's state carries over from
     job to job. You may account for this by resetting the browser's state
-    according to your needs, for which you can use [callbacks](../callbacks).
+    according to your needs, for which you can use [callbacks](callbacks.md).
 
 ### `UserAgentTimeoutError`: avoiding pool contention
 

data/docs/index.md

@@ -9,7 +9,7 @@ hide:
 ## Ruby web crawling framework built on [ActiveJob]() and [Redis]()
 
 <small>
-  [Read the tutorial](/guides/tutorial){ .md-button .md-button--primary }
+  [Read the tutorial](guides/tutorial.md){ .md-button .md-button--primary }
 </small>
 
 === "Command line"

data/lib/wayfarer/base.rb

@@ -116,16 +116,12 @@ module Wayfarer
       # chain included from {Controller}
       alias_method :perform, :call
 
-      use Wayfarer::Middleware::Redis
-      use Wayfarer::Middleware::UriParser
-      use Wayfarer::Middleware::Normalize
-      use Wayfarer::Middleware::Dedup
-      use Wayfarer::Middleware::BatchCompletion
-      use Wayfarer::Middleware::Stage
-      use Wayfarer::Middleware::Router
-      use Wayfarer::Middleware::UserAgent
-      use Wayfarer::Middleware::ContentType
-      use Wayfarer::Middleware::Dispatch
+      class_attribute :middleware,
+                      default: Wayfarer.config[:middleware][:base],
+                      instance_accessor: false,
+                      instance_predicate: false
+
+      include middleware.api
     end
 
     class_methods do