domino.core — domino/core 0.4.0-pre-alpha.4

add-conflicts-rx! clj/s

(add-conflicts-rx! state)

add-default-id clj/s

(add-default-id m)

add-effect-rxns! clj/s

(add-effect-rxns! state effects)

add-event-rxns! clj/s

(add-event-rxns! state events)

add-event-to-state! clj/s

(add-event-to-state! state
                     {:keys [id inputs outputs ctx-args handler async?
                             ignore-changes should-run]
                      :as event})

add-fields-to-ctx clj/s

(add-fields-to-ctx {:domino.core/keys [subcontexts] :as ctx}
                   [field :as fields]
                   on-complete)

add-incoming-effect-to-state! clj/s

(add-incoming-effect-to-state! state {:keys [id outputs handler] :as effect})

add-outgoing-effect-to-state! clj/s

(add-outgoing-effect-to-state! state
                               {:keys [id inputs ctx-args handler] :as effect})

always-inherit-ks clj/s

apply-db-initializers clj/s

(apply-db-initializers db inits)

clean-macc clj/s

(clean-macc opts {:keys [id] :as m})

compute-path clj/s

(compute-path ctx id)

compute-rels clj/s

(compute-rels rels)

constraint->reactions clj/s

(constraint->reactions constraint)

constraint->rels clj/s

(constraint->rels constraint)

create-new-context-in-collection clj/s

(create-new-context-in-collection ctx idx cb)

deep-relationships clj/s

(deep-relationships rel-map)

default-reactions clj/s

event->rels clj/s

(event->rels {:keys [id inputs outputs ctx-args handler async? ignore-changes
                     should-run]
              :as event})

get-constraint-ids clj/s

(get-constraint-ids state)

get-db clj/s

(get-db ctx)

get-downstream clj/s

(get-downstream {:domino.core/keys [downstream-deep subcontexts] :as ctx} id)

Gets all ids that could be affected by a change on the passed id.

get-in-db clj/s

(get-in-db ctx id)

Looks somewhat similar to select, but doesn't support arbitrary reactions

get-parents clj/s

(get-parents {:domino.core/keys [id->parents subcontexts] :as ctx} id)

Gets all parent ids for an id (i.e. referenced IDs which wholly contain the id's data)

get-path clj/s

(get-path ctx id)

See get-path!. Returns nil on no match instead of throwing.

get-path! clj/s

(get-path! {:domino.core/keys [id->path subcontexts]} id)

Given a domino context and an id, get the path to the value in the canonical DB

get-upstream clj/s

(get-upstream {:domino.core/keys [upstream-deep subcontexts] :as ctx} id)

Gets all ids which, if changed, may affect the passed id.

group-changes clj/s

(group-changes ctx changes)

ignore-final? clj/s

(ignore-final? {:domino.core/keys [ignore-finals? id->opts] :as ctx} id)

include-child-tx-reports clj/s

(include-child-tx-reports ctx)

initialize clj/s

(initialize schema)

(initialize schema cb-or-db)

(initialize schema initial-db cb)

is-collection? clj/s

(is-collection? ctx)

is-final? clj/s

(is-final? ctx id)

model-map-merge clj/s

(model-map-merge opts macc m)

normalize-schema clj/s

(normalize-schema schema)

parse-change clj/s

(parse-change ctx change)

parse-changes clj/s

(parse-changes ctx changes)

parse-reactions clj/s

(parse-reactions schema)

passing-constraint-result? clj/s

(passing-constraint-result? result)

pre-initialize clj/s

(pre-initialize schema)

pre-initialize-fields clj/s

(pre-initialize-fields ctx fields)

pre-initialize-rels clj/s

(pre-initialize-rels ctx schema)

resolve-changes clj/s

(resolve-changes ctx changes post-cb)

schema-is-async? clj/s

(schema-is-async? schema)

select clj/s

(select {:domino.core/keys [subcontexts rx db] :as ctx} id)

Given an id keyword or vector, select a value from a domino context.

transact clj/s

(transact ctx user-changes)

(transact {db-pre? :domino.core/db
           event-context :domino.core/event-context
           initialized? :domino.core/initialized?
           :as ctx-pre}
          user-changes
          cb)

trigger-effects clj/s

(trigger-effects ctx triggers)

(trigger-effects ctx triggers cb)

trimmed-opts clj/s

(trimmed-opts ctx id)

walk-model clj/s

(walk-model raw-model {:as opts})