fulcro.client.impl.data-fetch — fulcrologic/fulcro 2.6.1

append-target? clj/s

(append-target? t)

callback-env clj/s

(callback-env reconciler load-request original-env)

Build a callback env for post mutations and fallbacks

data-field clj/s

(data-field state)

Get the target field (if any) from the data state marker

data-ident clj/s

(data-ident state)

Return the ident (if any) of the component related to the query in the data state marker. An ident is required to be present if the marker is targeting a field.

data-marker clj/s

(data-marker state)

Returns the ID of the data marker, or nil/false if there isn't one. True means to use the old marker behavior of replacing the data in app state with a marker (DEPRECATED)

data-marker? clj/s

(data-marker? state)

Test if the user desires a copy of the state marker to appear in the app state at the data path of the target data.

data-params clj/s

(data-params state)

Get the parameters that the user wants to add to the first join/keyword of the data fetch query.

data-path clj/s

(data-path state)

Get the app-state database path of the target of the load that the given data state marker is trying to load.

data-query clj/s

(data-query state)

Get the query that will be sent to the server as a result of the given data state marker

data-query-key clj/s

(data-query-key state)

Get the 'primary' query key of the data fetch. This is defined as the first keyword of the overall query (which might be a simple prop or join key for example)

data-refresh clj/s

(data-refresh state)

Get the list of query keywords that should be refreshed (re-rendered) when this load completes.

data-remote clj/s

(data-remote state)

Get the remote that this marker is meant to talk to

data-state? clj/s

(data-state? state)

Test if the given bit of state is a data fetch state-tracking marker

data-target clj/s

(data-target state)

Return the ident (if any) of the component related to the query in the data state marker. An ident is required to be present if the marker is targeting a field.

data-uuid clj/s

(data-uuid state)

Get the UUID of the data fetch

dedupe-by clj/s

(dedupe-by keys-fn)

(dedupe-by keys-fn coll)

Returns a lazy sequence of the elements of coll with dupes removed. An element is a duplicate IFF (keys-fn element) has key collision with any prior element to come before it. E.g. (dedupe-by identity [[:a] [:b] [:a] [:a :c]]) => [[:a] [:b]] Returns a stateful transducer when no collection is provided.

earliest-load-time clj/s

(earliest-load-time load-markers)

Given a sequence of load markers, returns the history tx-time of the earliest one. Returns hist/max-tx-time if there are no markers or none have a time.

elide-ast-nodes clj/s

(elide-ast-nodes {:keys [key union-key children] :as ast} elision-set)

Remove items from a query (AST) that have a key listed in the elision-set

failed? clj/s

(failed? state)

Test if the given item is a data state marker in the failed state

full-query clj/s

(full-query items)

Composes together the queries of a sequence of data states into a single query.

inject-query-params clj/s

(inject-query-params ast params)

Inject parameters into elements of the top-level query.

params is a map from keyword (on the query in the AST) to parameter maps. So, given the AST for this query:

[:a :b :c]

and a params of {:a {:x 1} :c {:y 2}} you'll get an AST representing:

[(:a {:x 1}) :b (:c {:y 2})]

is-deferred-transaction? clj/s

(is-deferred-transaction? query)

Returns true if the outgoing query is just a placeholder indicator for a deferred transaction in the load queue.

is-direct-table-load? clj/s

(is-direct-table-load? load-marker)

loading? clj/s

(loading? state)

Test if the given item is a data state marker in the loading state

make-data-state clj/s

(make-data-state type)

(make-data-state type params)

This is just a testing function -- using ready-state as public interface and call the set-{type}! functions to change it as needed.

mark-loading clj/s

(mark-loading remote reconciler)

Marks all of the items in the ready-to-load state as loading, places the loading markers in the appropriate locations in the app state, and returns a map with the keys:

query : The full query to send to the server. on-load : The function to call to merge a response. Detects missing data and sets failure markers for those. on-error : The function to call to set network/server error(s) in place of loading markers. load-descriptors : Args to pass back to on-load and on-error. These are separated so that rewrite-tempids-in-request-queue can rewrite tempids for merge and error callbacks

response-channel will have the response posted to it when the request is done. .

mark-parallel-loading! clj/s

(mark-parallel-loading! remote-name reconciler)

Marks all of the items in the ready-to-load state as loading, places the loading markers in the appropriate locations in the app state, and return maps with the keys:

query : The full query to send to the server. on-load : The function to call to merge a response. Detects missing data and sets failure markers for those. on-error : The function to call to set network/server error(s) in place of loading markers. load-descriptors : Args to pass back to on-load and on-error. These are separated so that rewrite-tempids-in-request-queue can rewrite tempids for merge and error callbacks

response-channel will have the response posted to it when the request is done. .

mark-ready clj/s

(mark-ready {:keys [env] :as config})

Place a ready-to-load marker into the application state. This should be done from a mutate function that is abstractly loading something. This is intended for internal use.

See the load and load-field functions in fulcro.client.data-fetch for the public API.

marker-table clj/s

multiple-targets? clj/s

(multiple-targets? t)

optional clj/s

(optional pred)

prepend-target? clj/s

(prepend-target? t)

process-target clj/s

ready-state clj/s

(ready-state {:keys [ident field params remote without query post-mutation
                     post-mutation-params fallback parallel refresh marker
                     target env initialize abort-id]
              :or {remote :remote without #{} refresh [] marker true}})

Generate a ready-to-load state with all of the necessary details to do remoting and merging.

ready? clj/s

(ready? state)

Test if the given item is a data state marker that is in the ready state

relocate-targeted-results! clj/s

(relocate-targeted-results! state-atom items)

For items that are manually targeted, move them in app state from their result location to their target location.

replacement-target? clj/s

(replacement-target? t)

set-failed! clj/s

(set-failed! state)

(set-failed! state params)

Returns a marker (based on the input state) that is in the error state

set-loading! clj/s

(set-loading! state)

(set-loading! state params)

Returns a marker (based on the input state) that is in the loading state (and ensures that it has a UUID)

set-ready! clj/s

(set-ready! state)

(set-ready! state params)

Returns a state (based on the input state) that is in the 'ready' to load state.

special-target? clj/s

(special-target? t)

split-items-ready-to-load clj/s

(split-items-ready-to-load items-ready-to-load)

This function is used to split accidental colliding queries into separate network requests. The most general description of this issue is from two unrelated load calls when black-box composing functions. The two separate queries: One issues [{:entitlements [:foo]}], and the other asks for [{:entitlements [:bar]}]. Fulcro merges these into a single query [{:entitlements [:foo]} {:entitlements [:bar]}]. However, the response to a query is a map, and such a query would result in the backend parser being called twice (once per key in the subquery) but one would stomp on the other.

The other potential collision is if a load includes an abort ID. In this case such a load should not be batched with others because aborting it would take others down with it.

Thus, this function ensures such accidental collisions are not combined into a single network request.

This functions returns a list of the load items that can be batched (from the beginning, in order) and the remainder of the items which must be deferred to another request.

valid-types clj/s