com.fulcrologic.fulcro.algorithms.tx-processing — com.fulcrologic/fulcro 3.1.21

The transaction processing in Fulcro is (intended to be) pluggable. This namespace is the implementation for the default transaction processing . At the present time there is no documentation on how such an override would be written, nor is it necessarily recommended since many of the desirable and built-in behaviors of Fulcro are codified here.

activate-submissions! clj/s

(activate-submissions! {:keys [:com.fulcrologic.fulcro.application/runtime-atom]
                        :as app})

Activate all of the transactions that have been submitted since the last activation. After the items are activated a single processing step will run for the active queue.

active-remotes clj/s

(active-remotes queue remotes)

Calculate which remotes still have network activity to do on the given active queue.

add-send! clj/s

(add-send! {:com.fulcrologic.fulcro.application/keys [runtime-atom] :as app}
           {:com.fulcrologic.fulcro.algorithms.tx-processing/keys [id options]
            :as tx-node}
           ele-idx
           remote)

Generate a new send node and add it to the appropriate send queue. Returns the new send node.

advance-actions! clj/s

(advance-actions! app
                  {:com.fulcrologic.fulcro.algorithms.tx-processing/keys
                     [id elements]
                   :as node})

Runs any incomplete and non-blocked optimistic operations on a node.

app->remote-names clj/s

(app->remote-names app)

Returns a set of the names of the remotes from an app

app->remotes clj/s

(app->remotes app)

Returns the remotes map from an app

build-env clj/s

(build-env app
           {:keys [:com.fulcrologic.fulcro.algorithms.tx-processing/options]
            :as tx-node})

(build-env app
           {:com.fulcrologic.fulcro.algorithms.tx-processing/keys [options]
            :as tx-node}
           addl)

combine-sends clj/s

(combine-sends app remote-name send-queue)

Takes a send queue and returns a map containing a new combined send node that can act as a single network request, along with the updated send queue.

compute-desired-ast-node clj/s

(compute-desired-ast-node app remote tx-node tx-element)

Add the ::desired-ast-nodes and ::transmitted-ast-nodes for remote to the tx-element based on the dispatch for the remote of the original mutation.

dispatch-elements clj/s

(dispatch-elements tx-node env dispatch-fn)

Run through the elements on the given tx-node and do the side-effect-free dispatch. This generates the dispatch map of things to do on that node.

dispatch-result! clj/s

(dispatch-result! app
                  tx-node
                  {:com.fulcrologic.fulcro.algorithms.tx-processing/keys
                     [results dispatch desired-ast-nodes transmitted-ast-nodes
                      original-ast-node]
                   :as tx-element}
                  remote)

Figure out the dispatch routine to trigger for the given network result. If it exists, send the result to it.

Returns the tx-element with the remote marked complete.

distribute-element-results! clj/s

(distribute-element-results!
  app
  tx-node
  {:keys [:com.fulcrologic.fulcro.algorithms.tx-processing/results
          :com.fulcrologic.fulcro.algorithms.tx-processing/complete?]
   :as tx-element})

Distribute results and mark the remotes for those elements as complete.

distribute-results! clj/s

(distribute-results!
  app
  {:keys [:com.fulcrologic.fulcro.algorithms.tx-processing/elements]
   :as tx-node})

Walk all elements of the tx-node and call result dispatch handlers for any results that have not been distributed.

element-with-work clj/s

(element-with-work
  remote-names
  {:keys [:com.fulcrologic.fulcro.algorithms.tx-processing/dispatch
          :com.fulcrologic.fulcro.algorithms.tx-processing/started?]
   :as element})

Returns a txnode element iff it has remaining (remote) work that has not been queued. Returns nil if there is no such element.

remote-names is the set of legal remote names.

every-ast? clj/s

(every-ast? ast-node-or-tree test)

Check if the given test predicate is true for an AST node or for all the immediate children of an AST tree.

extract-parallel clj/s

(extract-parallel sends)

Splits the given send queue into two send queues: [parallel-items sequential-items].

fully-complete? clj/s

(fully-complete? app
                 {:keys
                    [:com.fulcrologic.fulcro.algorithms.tx-processing/elements]
                  :as tx-node})

idle-node? clj/s

(idle-node? {:keys [:com.fulcrologic.fulcro.algorithms.tx-processing/elements]
             :as tx-node})

Returns true if the given node has no active network operations.

mutation-ast? clj/s

(mutation-ast? ast-node-or-tree)

Returns true if the given AST node or tree represents a mutation or sequence of mutations.

net-send! clj/s

(net-send! app send-node remote-name)

Process the send against the user-defined remote. Catches exceptions and calls error handler with status code 500 if the remote itself throws exceptions.

process-queue! clj/s

(process-queue!
  {:com.fulcrologic.fulcro.application/keys [state-atom runtime-atom] :as app})

Run through the active queue and do a processing step.

process-send-queues! clj/s

(process-send-queues! {:com.fulcrologic.fulcro.application/keys [runtime-atom]
                       :as app})

Process the send queues against the remotes. Updates the send queues on the app and returns the updated send queues.

process-tx-node! clj/s

(process-tx-node! app
                  {:keys
                     [:com.fulcrologic.fulcro.algorithms.tx-processing/options]
                   :as tx-node})

query-ast? clj/s

(query-ast? ast-node-or-tree)

Returns true if the given AST node or tree represents a mutation or sequence of mutations.

queue-element-sends! clj/s

(queue-element-sends!
  app
  tx-node
  {:keys [:com.fulcrologic.fulcro.algorithms.tx-processing/idx
          :com.fulcrologic.fulcro.algorithms.tx-processing/dispatch
          :com.fulcrologic.fulcro.algorithms.tx-processing/started?]})

Queue all (unqueued) remote actions for the given element. Returns the (possibly updated) node.

queue-next-send! clj/s

(queue-next-send! app
                  {:keys
                     [:com.fulcrologic.fulcro.algorithms.tx-processing/elements]
                   :as tx-node})

Assumes tx-node is to be processed pessimistically. Queues the next send if the node is currently idle on the network and there are any sends left to do. Adds to the send queue, and returns the updated tx-node.

queue-sends! clj/s

(queue-sends! app
              {:keys [:com.fulcrologic.fulcro.algorithms.tx-processing/options
                      :com.fulcrologic.fulcro.algorithms.tx-processing/elements]
               :as tx-node})

Finds any item(s) on the given node that are ready to be placed on the network queues and adds them. Non-optimistic multi-element nodes will only queue one remote operation at a time.

record-result! clj/s

(record-result! app txn-id ele-idx remote result)

(record-result! {:com.fulcrologic.fulcro.application/keys [runtime-atom]
                 :as app}
                txn-id
                ele-idx
                remote
                result
                result-key)

Record a network result on the given txn/element. If result-key is given it is used, otherwise defaults to ::results. Also removes the network send from the send queue so that remaining items can proceed, and schedules send processing.

remotes-active-on-node clj/s

(remotes-active-on-node
  {:com.fulcrologic.fulcro.algorithms.tx-processing/keys [elements] :as tx-node}
  remotes)

Given a tx node and the set of legal remotes: returns a set of remotes that are active on that node.

remove-send! clj/s

(remove-send! {:com.fulcrologic.fulcro.application/keys [runtime-atom] :as app}
              remote
              txn-id
              ele-idx)

Removes the send node (if present) from the send queue on the given remote.

requested-refreshes clj/s

(requested-refreshes app queue)

run-actions! clj/s

(run-actions! app
              {:com.fulcrologic.fulcro.algorithms.tx-processing/keys [id
                                                                      elements]
               :as node})

schedule-activation! clj/s

(schedule-activation! app)

(schedule-activation! app tm)

Schedule activation of submitted transactions. The default implementation copies all submitted transactions onto the active queue and immediately does an active queue processing step. If tm is not supplied (in ms) it defaults to 10ms.

schedule-queue-processing! clj/s

(schedule-queue-processing! app)

(schedule-queue-processing! app tm)

Schedule a processing of the active queue, which will advance the active transactions by a step. If tm is not supplied (in ms) it defaults to 10ms.

schedule-sends! clj/s

(schedule-sends! app)

(schedule-sends! app tm)

Schedule actual network activity. If tm is not supplied (in ms) it defaults to 0ms.

sort-queue-writes-before-reads clj/s

(sort-queue-writes-before-reads send-queue)

Sort function on a send queue. Leaves any active nodes in front, and sorts the remainder of the queue so that writes appear before reads, without changing the relative order in blocks of reads/writes.

top-keys clj/s

(top-keys {:keys [type key children] :as ast})

tx-node clj/s

(tx-node tx)

(tx-node tx options)

update-progress! clj/s

(update-progress! app
                  {:keys
                     [:com.fulcrologic.fulcro.algorithms.tx-processing/elements]
                   :as tx-node})

Report all progress items to any registered progress dispatch and clear them from the tx-node. Returns the updated tx-node.