org.clojars.roklenarcic.paginator — org.clojars.roklenarcic/paginator 0.1.0

Paginator enables paginating multiple concurrent items with batching.

engine clj

(engine result-parser)

(engine result-parser get-items-fn)

(engine result-parser get-items-fn async-fn)

Defines a minimal map describing the paging engine. Use with-* to add more options.

async-fn is a fn that takes a no-arg fn and runs it asynchronously, defaults to future-call

get-items-fn is a fn of (params, paging-states) that should return some sort of a response, that will be parsed by result-parser, defaults to get-items multimethod

result-parser is a protocols/ResultParser instance

Default buffer size for result channel is 100. Default concurrency is 1, see with-concurrency docs for meaning of this setting.

get-items clj multimethod

Multimethod that should perform a request for a specific :entity-type and return a response.

paginate! clj

(paginate! engine params entity-ids)

Loads pages with given entity-id pairs. Returns a vector of paging states. Any exceptions are rethrown. entity-ids should be a coll of pairs of entity-type and id.

paginate*! clj

(paginate*! engine params)

Returns a channel for inbound paging state maps and a channel where the paging state maps are returns with additional keys of :items or :exception.

They are returned in the map as :in and :out keys respectively.

paginate-coll! clj

(paginate-coll! engine params entity-type ids)

Loads pages with given IDs. Returns a vector of vectors where each subvector represents items for the id at that index in input parameters. Any exceptions are rethrown.

paginate-one! clj

(paginate-one! engine params entity-type id)

Starts pagination on a single entity and returns items. It expects that there is only 1 result.

Params is merged into paging states map.

paging-state clj

(paging-state entity-type entity-id)

Returns a base data-structure that describes initial state in paging of results based on some entity.

Initially it doesn't have a :page-cursor key. If the key is present and nil, the entity is considered to be finished caching.

result-parser clj

(result-parser items-fn cursor-fn new-entities-fn)

Returns a proto/ResultParser, the functions given have the same argument list as the protocol.

result-parser1 clj

(result-parser1 items-fn cursor-fn)

(result-parser1 items-fn cursor-fn new-entities-fn)

Returns a proto/ResultParser that expects that response has 1 item and 1 cursor

• items-fn takes a batch-result returns a collection of items for the paging-state
• cursor-fn takes a batch-result returns a cursor
• new-entities-fn takes a batch-result and returns coll of paging states for new entities, defaults to a function that always returns []

throw-states-exceptions clj

(throw-states-exceptions states)

Throws any exceptions in the states given.

with-batcher clj

(with-batcher engine sorted?)

(with-batcher engine sorted? max-items)

(with-batcher engine sorted? max-items batch-fn)

Add batching configuration to engine map.

sorted? enables using sorted map instead of normal for keeping batches. This comes into play when you have multiple unfinished batches and one needs to be picked for processing, with sorted map the batches with lowest batch key go first.

max-items is the batch size. If pipeline stalls because no batches are available with max size, smaller batches are issued.

batch-fn is the function to generate batch key from paging state map. Defaults to :entity-type

with-concurrency clj

(with-concurrency engine concurrency)

with-items-fn clj

(with-items-fn engine get-items-fn)

with-result-buf clj

(with-result-buf engine buf-size)

The buffer size for the result channel.