paginationMiddleware

Middleware to activate pagination on an endpoint.

This should not be added globally. It should be added to each Endpoint
that requires pagination.

Usage:

```js
new Endpoint(new UrlPattern('/users/'), {
  middleware: [paginationMiddleware()]
})
```

Or to customise the paginatorClass

```js
new Endpoint(new UrlPattern('/users/'), {
  middleware: [paginationMiddleware(PageNumberPaginator)]
})
```


The pagination class to use. Defaults to [InferredPaginator](doc:InferredPaginator).


paginatorClass

PaginatorInterfaceClass

options

PaginationMiddlewareOptions

MiddlewareObject

currentState

State

internalState

InternalState

responseIsSet

boolean

setCurrentState

__type

__call

setInternalState

first

void

firstState

getRequestInit

PaginatorRequestOptions

hasNextPage

nextState

previousState

replaceStateControllers

currentStatePair

internalStatePair

setResponse

response

Properties

Methods

CursorPaginator

InferredPaginator

LimitOffsetPaginator

PageNumberPaginator

Paginator

PaginatorInterface

null

Record

constructor

new PaginatorInterfaceClass

args

Function

FunctionConstructor

Function.arguments

arguments

Function.caller

caller

Function.length

length

number

Returns the name of the function. Function names are read-only and can not be changed.

Function.name

name

string

Function.prototype

prototype

Function.[Symbol.hasInstance]

[Symbol.hasInstance]

Determines whether the given value inherits from this function if this function was used
as a constructor function.

A constructor function can control which objects are recognized as its instances by
'instanceof' by overriding this method.


value

Function.apply

apply

Calls the function, substituting the specified object for the this value of the function, and the specified array for the arguments of the function.

this

thisArg

argArray

Function.bind

bind

For a given function, creates a bound function that has the same body as the original function.
The this object of the bound function is associated with the specified object, and has the specified initial parameters.

Function.call

call

Calls a method of an object, substituting another object for the current object.

getPaginationState

requestDetails

Function.toString

toString

Returns a string representation of a function.

Constructors

new Paginator

PaginatorInterface.currentState

PaginatorInterface.internalState

PaginatorInterface.setCurrentState

PaginatorInterface.setInternalState

True once setResponse has been called and pagination state is known.

__get

PaginatorInterface.responseIsSet

PaginatorInterface.first

PaginatorInterface.firstState

Does not transition state. To transition state call `first` instead.


PaginatorInterface.getRequestInit

Return the options to use with `Endpoint.execute` or `Endpoint.prepare`. Usually
this just involves setting `query` to the query string parameters for the paginator
but can also provide custom headers or different URL resolve arguments.

PaginatorInterface.hasNextPage

Returns true if there's more results after the current page

PaginatorInterface.next

PaginatorInterface.nextState

Does not transition state. To transition state call `next` instead.


PaginatorInterface.previous

PaginatorInterface.previousState

Does not transition state. To transition state call `previous` instead.


PaginatorInterface.replaceStateControllers

Paginator receives 2 tuples of a state and state setter pair. This is expected to
match the same interface as `useState` in React. The following is a valid simple usage:

```js
const paginator = new Paginator(useState(), useState());
```

Note that we can also pass the state controllers in via `replaceStateControllers` rather
than in the constructor. This is so we can memoize the `Paginator` instance which is desirable
when using the paginator as a dependency to React hooks.

As state is passed in and managed external to the class be aware that any data stored
on the class instance will be lost unless written with `setCurrentState` or `setInternalState`.
This design is a compromise between allowing a clear interface for how paginators should
be defined and allowing the state to be managed externally (eg. using React state).


PaginatorInterface.setResponse

This is called when an `Endpoint` has resolved and is passed the response from the
endpoint. This is used to update the relevant paginator state  - eg. the total
number of records, next & previous cursors etc.

Accessors

Variables

The state object and setter (eg. from `useState`) that is used to store
and transition pagination state. Using this you can do things like easily store state in the URL
(eg. using `useUrlQueryState`) or other data sources.

The state object and setter that is used for internal state. Internal state
is stored separately as it does not need to be restored (eg. if you refresh the page). It is used
to store things like the total number of results or the current cursor. Passing `useState` here is
fine.


The response as returned by the endpoint this paginator is used with.


Omit

RequestInit

headers

query

urlArgs

eg. the return value from [Endpoint.execute](doc:Endpoint#method-execute)

PaginationRequestDetails

The value returned by `decodedBody`. See [Endpoint.execute](doc:Endpoint#method-execute).

This may be a sub-key of the data returned by `Endpoint.execute`, eg. if the `path` option is used in
[paginationMiddleware](doc:paginationMiddleware). eg. If `decodedBody` from the `Endpoint` was

```json
{
    users: {
        count: 10,
        results: [...],
    }
    extraDetails: {...}
}
```

and `paginationMiddleware` was used with `path: 'users'` then `decodedBody` would be:

```json
{
    count: 10,
    results: [...]
}
```


decodedBody

Response

new UrlPattern

pattern

UrlPattern

keys

requiredArgNames

toPath

PathFunction

validArgNames

resolve

kwargs

__namedParameters

Allows definition of URL as a pattern with ability to resolve it to a URL by performing argument replacement

Patterns are defined using the [path-to-regexp](https://github.com/pillarjs/path-to-regexp) library

Usage:

```js
const url = new UrlPattern('/users/:id/'),
url.resolve({ id: 5 });
// /users/5/
url.resolve({ id: 5 }, { query: { showAddresses: true }});
// /users/5/?showAddresses=true
```


__index

Query

new SkipToResponse

promise

SkipToResponse

Promise

This can be passed to `next` in middleware to skip all subsequent middleware in the chain, the call
to `fetch` and resolve instead to the `promise` passed in.

This is useful for middleware like [dedupeInFlightRequestsMiddleware](doc:dedupeInFlightRequestsMiddleware) where
if a duplicate request is detected it just needs to wait for the original request to finish and return the
same Response object.

It can also be used to change how `fetch` is performed (`batchMiddleware` uses this).

For example this just calls a completely different URL and uses the response object from that:

```js
function customFetchMiddleware(next, urlConfig, requestInit, context) {
  return next(new SkipToResponse(
      return fetch('/somewhere-else/');
  ));
}
```

Note that this completely bypasses any subsequent middleware in the chain (including response handling) so any
security-related middleware should come before this.


Should not be instantiated manually. This is created by `Endpoint` as part of processing a request.

new MiddlewareContext

MiddlewareContext

_fetchStartCallbacks

The endpoint the middleware is executing within.

endpoint

Endpoint

Function to re-execute the Endpoint. Accepts no arguments - it replays the request with identical arguments
as the first time. This will go through the full middleware cycle again. This is useful for middleware
that may replay a request after an initial failure, eg. if user isn't authenticated on initial attempt.

execute

The original options passed to [execute](doc:Endpoint#method-execute)

executeOptions

EndpointExecuteOptions

The state as of when the last middleware in the chain was processed.

This contains the `url`, `response`, `decodedBody` and `result`.


lastState

MiddlewareNextReturn

The options used to execute the endpoint with

requestInit

EndpointRequestInit

addFetchStartListener

Listen for the start of the call to `fetch`. The callback will be called immediately
after `fetch` is called and is passed the `Promise` returned by `fetch`.

This is useful for middleware like [dedupeInFlightRequestsMiddleware](doc:dedupeInFlightRequestsMiddleware)
that need access to the `fetch` `Promise` directly. It can then cache the promise and subsequently pass it to
[SkipToResponse](doc:SkipToResponse) to make other calls to an `Endpoint` use the same `fetch` `Response`.


callback

markResponseDecoded

You likely don't need this; use `decodeBody` on `Endpoint` instead. This is useful in cases
where you want to bypass the normal `Endpoint` `decodeBody` functionality (for example in
`batchMiddleware`).


notifyFetchStart

Called internally by `Endpoint` to notify when `fetch` has started.

fetchPromise

An instance of this is passed as the fourth parameter to middleware functions.

init

undefined

prepare

process

MiddlewareFunction

Object form of middleware. This allows more control over what the middleware can do. Specifically allows middleware
to define how it interacts with `Endpoint.prepare` and allows modifications to the `Endpoint` via `init`.

	Parameter	Type	Description
*	paginatorClass	PaginatorInterfaceClass	The pagination class to use. Defaults to InferredPaginator.
	options.getPaginationState	Function	Function that returns the state for a paginator based on the response. If not provided uses the static `getPaginationState` method on the `paginatorClass`. You can use this method if your backend needs to transform the response before being handled by `paginatorClass`. This can be useful to use a built in paginator (eg. PageNumberPaginator) where a data structure from the backend differs from that expected.
	options.resultPath	string	Optional path to where in data the pagination state exists. Dotted notation is accepted (see below example). If this is provided only this section of the data object will be updated. For example if the return data looked like: { records: { users: { count: 10, results: [...] }, products: [...] } extra: { ... } } And `resultPath` was set to `records.users` then the returned data would be { records: { users: [...], // pagination state extracted, `results` set products: [...], // unchanged } extra: { ... } // unchanged }