Check whether the given value implements the Resolvable protocol.

Interface for values that can be resolved in batches.

Do not use with extend-type or extend-protocol!

Find all errors within the given value.

Protocol describing resolution cost for a batch of resolvables. The following default values are produced:

• 0 for batches of PureResolvable,
• 1 for batches of BatchedResolvables
• (count batch) for other batches.

The overall cost can be used when declaring engines by supplying the :max-cost option.

Calculate the cost of resolution for the given batch.

Generate a value representing a resolution error.

Retrieve error data from the given error value.

Retrieve the message from the given error value.

Check whether the given value represents a resolution error.

Implement the Transform protocol for the given resolvable-class, assuming it returns a seq of elements to-be-processed with element-constructor.

(extend-list-transform
  PeopleByLocation
  [->Person])

This is equivalent to:

(extend-protocol claro.data/Transform
  PeopleByLocation
  (transform [_ results]
    (mapv ->Person results)))

It’s also possible to supply extra parameters to be passed to the element constructor, e.g.:

(extend-list-transform
  PeopleByLocation
  [->Person {:by :location}])

This will call (->Person element {:by :location}) on each element.

Implement the Transform protocol for the given resolvable-class by transforming/renaming fields according to a given field spec.

(extend-transform
  Person
  {:pet      [->Pet :pet-id]
   :location (fn [{:keys [latitude longitude]}]
               (->Location latitude longitude))
   :name     :username})

This will:

• create :pet as (->Pet (:pet-id result)),
• create :location as the result of the given function, and
• copy :username to :name.

All these take the resolution result (!) as input but will not alter nil values.

Marker interface for mutations, applying the following constraints on resolution:

• only resolve on top-level (i.e. resolve! cannot return a mutation),
• only resolve one mutation per run,
• run mutation before any other resolvables.

Do not use with extend-type or extend-protocol.

Protocol for custom parameter handling for Resolvables.

Protocol enhancing batching capabilities by allowing batches to be partitioned using some per-resolvable-class criterion.

This is only used for batched resolvables.

Calculate a partitioning key for the given resolvable. Resolvables with the same partitioning key will be resolved within the same batch.

Check whether the given value implements the PureResolvable protocol.

Interface for values whose resolution is done using a pure function, i.e. there is no I/O or statefulness involved.

Do not use with extend-type or extend-protocol!

Interface for resolvable values.

Do not use with extend-type or extend-protocol!

Check whether the given value implements the Resolvable protocol.

NOTE: Before version 0.2.7 this did not return true for BatchedResolvable records.

Resolve the given value within the given environment, returning a manifold deferrable representing the resolution result. This might yield a structure containing more Resolvables.

Resolve all-resolvables (which is a seq including resolvable), returning a manifold deferrable containing a seq with resolved values in-order.

Set the current resolvable’s parameters, returning an updated resolvable.

This is used by the parameters projection for injection.

Protocol for post-processing the result of resolve! and the single results of resolve-batch!.

Transform the result of resolve! (or a single result of resolve-batch!) for the current Resolvable class..