a-frame.interceptor-chain — com.github.yapsterapp/a-frame 3.0.24-alpha1

after-enter-update-context clj/s

(after-enter-update-context {queue :a-frame.interceptor-chain/queue
                             stack :a-frame.interceptor-chain/stack
                             _history :a-frame.interceptor-chain/history
                             :as context}
                            interceptor-spec
                            new-history)

update a context after the enter fn has been processed

after-leave-update-context clj/s

(after-leave-update-context {stack :a-frame.interceptor-chain/stack
                             _history :a-frame.interceptor-chain/history
                             _error :a-frame.interceptor-chain/error
                             :as context}
                            interceptor-fn-key
                            has-thunk?
                            _interceptor-spec
                            new-history)

update a context after a leave fn has been processed

assoc-opaque-keys clj/s

(assoc-opaque-keys ctx app-ctx a-frame-router)

add the opaque keys to the interceptor context

they are removed from reported contexts by sanitise-context

clear-error clj/s

(clear-error context)

Removes any associated ::error from context

context-keys clj/s

The Interceptor specific keys that are added to contexts

dissoc-context-keys clj/s

(dissoc-context-keys context)

Removes all interceptor related keys from context

enqueue clj/s

(enqueue context interceptors)

Adds interceptors to the end of the interceptor queue within context

enter-all clj/s

(enter-all context)

Process the :queue of context, calling each :enter fn in turn.

If an error is raised it is captured, stored in the contexts :error key, and the queue is cleared (to prevent further processing.)

enter-next clj/s

(enter-next {queue :a-frame.interceptor-chain/queue
             _stack :a-frame.interceptor-chain/stack
             _history :a-frame.interceptor-chain/history
             :as context})

Executes the next ::enter interceptor queued within context, returning a promise that will resolve to the next pr-loop-context action to take

execute clj/s

(execute app-ctx a-frame-router interceptor-chain initial-context)

Returns a Promise encapsulating the execution of the given [[InterceptorContext]].

Runs all :enter interceptor fns (in FIFO order) and then all :leave fns (in LIFO order) returning the end result context map.

If an error occurs during execution :enter processing is terminated and the :error handlers of all executed interceptors are called (in LIFO order), with the original error wrapped in an ex-info with ex-data containing the ::context at the point of failure - this can be used to resume processing from the failure point

If the resulting context still contains an error after this processing it will be re-thrown when the execution promise is realised.

execute* clj/s

(execute* context)

execute a context

final-error-handler clj/s

(final-error-handler {err :a-frame.interceptor-chain/error :as ctx})

initiate clj/s

(initiate app-ctx a-frame-router interceptor-chain initial-context)

Given a sequence of [[InterceptorSpec]]s and a map of initial-context values, returns a new [[InterceptorContext]] ready to execute

initiate* clj/s

(initiate* interceptor-chain)

(initiate* initial-context interceptor-chain)

interceptor-data-key clj/s

(interceptor-data-key interceptor-fn-key)

interceptor-fn-history-thunk clj/s

(interceptor-fn-history-thunk interceptor-fn-key interceptor-spec context error)

returns a [<history-entry> <interceptor-fn-thunk>]

leave-all clj/s

(leave-all context)

Process the ::stack of context, calling, in LIFO order.

If an ::error is present in the context then the ::error handling fn of the interceptors will be called otherwise the :leave fns will be called.

Any thrown errors will replace the current ::error with stack unwinding continuing from that point forwards.

leave-next clj/s

(leave-next {stack :a-frame.interceptor-chain/stack
             _history :a-frame.interceptor-chain/history
             error :a-frame.interceptor-chain/error
             :as context})

Executes the next ::leave or ::error interceptor on the stack within context, returning a promise that will resolve to the next pr-loop-context action to take

maybe-execute-interceptor-fn clj/s

(maybe-execute-interceptor-fn interceptor-fn-key interceptor-spec context error)

call an interceptor fn on an interceptor, resolving any supplied data

maybe-execute-interceptor-fn-thunk clj/s

(maybe-execute-interceptor-fn-thunk thunk context)

normalize-interceptor-spec clj/s

(normalize-interceptor-spec interceptor-spec)

turns keyword interceptor-specs into maps {::key <interceptor-key>}

opaque-context-keys clj/s

keys which contain opaque data

pr-loop-context clj/s

(pr-loop-context context step-fn)

pr-loop-context* clj/s

(pr-loop-context* context step-fn)

Helper fn to repeat execution of step-fn against context inside a promise loop.

step-fn should return a tuple of either [::break <value>] or [::recur <new context>]. The former will terminate the loop and return <value>, the later will pass <new context> to the next loop iteration.

(Note: this mainly exists to abstract away and minimise the platform specific aspects of handling promise loops.)

register-interceptor clj/s

(register-interceptor interceptor-key interceptor)

resolve-interceptor clj/s

(resolve-interceptor interceptor-key)

resolve-interceptor-data clj/s

(resolve-interceptor-data interceptor-fn-key interceptor-spec context)

resolve the interceptor data, returning either

• [data-val] if there was data specified
• nil if no data was specified

resume clj/s

(resume app-ctx a-frame-router err-or-resume-context)

resume a failed interceptor chain, from either a thrown exception or a logged resume-context

sanitise-context clj/s

(sanitise-context context)

remove impure / opaque data from a context

terminate clj/s

(terminate context)

Removes all queued interceptors from context

unwrap-original-error clj/s

(unwrap-original-error e)

unwrap layers of error wrapping (in case of nested :dispatch) to get at the causal exception

wrap-error clj/s

(wrap-error resume-context e)

wrap-interceptor-error clj/s

(wrap-interceptor-error resume-context new-context e)

wrap an exception and record the error