domino.core — domino/core 0.4.0-alpha.3

add-conflicts-rx! clj/s

(add-conflicts-rx! rx-map)

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])

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

append-db-hash! clj/s

(append-db-hash! ctx)

Add a new db hash to the set of encountered hashes, error if duplicate is found.

append-events-to-queue clj/s

(append-events-to-queue {hist :domino.core/event-history
                         event-queue :domino.core/event-queue
                         :as ctx})

Add any pending events (which aren't ignored) to the event queue. Events with :evaluation :once will bubble to the tail of the queue.

apply-db-initializers clj/s

(apply-db-initializers db inits)

change-is-async? clj/s

(change-is-async? ctx change)

clean-macc clj/s

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

clear-transaction-data clj/s

(clear-transaction-data ctx)

compute-rels clj/s

(compute-rels rels)

constraint->reactions clj/s

(constraint->reactions constraint)

constraint->rels clj/s

(constraint->rels constraint)

create-element clj/s

(create-element subcontext index)

(create-element subcontext index db)

create-element-async clj/s

(create-element-async subcontext index db on-success on-fail)

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

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

db-changed? clj/s

(db-changed? ctx)

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 rx-map)

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-resolution-changeset! clj/s

(get-resolution-changeset! ctx)

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)

initial-transact clj/s

(initial-transact ctx db)

initial-transact-async clj/s

(initial-transact-async ctx db on-success on-fail)

initialize clj/s

(initialize schema)

(initialize schema initial-db)

initialize-all-subcontexts clj/s

(initialize-all-subcontexts ctx)

initialize-all-subcontexts-async clj/s

(initialize-all-subcontexts-async ctx on-success on-fail)

initialize-async clj/s

(initialize-async schema initial-db on-success on-fail)

initialize-db clj/s

(initialize-db ctx initial-db)

initialize-subcontext clj/s

(initialize-subcontext ctx subctx-id subcontext)

initialize-subcontext-async clj/s

(initialize-subcontext-async ctx subctx-id subcontext on-success on-fail)

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)

post-initialize clj/s

(post-initialize ctx initial-db)

post-initialize-async clj/s

(post-initialize-async ctx initial-db on-success on-fail)

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)

prevent-change-to-final! clj/s

(prevent-change-to-final! ctx change)

resolve-change clj/s

(resolve-change ctx-pre change)

resolve-change-async clj/s

(resolve-change-async ctx change on-success on-fail)

resume-transaction clj/s

(resume-transaction {db-pre :domino.core/db
                     event-context :domino.core/event-context
                     changes :domino.core/pending-changes
                     :as ctx-pre})

resume-transaction-async clj/s

(resume-transaction-async {db-pre :domino.core/db
                           event-context :domino.core/event-context
                           changes :domino.core/pending-changes
                           :as ctx-pre}
                          on-success
                          on-fail)

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.

set-initial-rx-root clj/s

(set-initial-rx-root ctx)

transact clj/s

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

transact-async clj/s

(transact-async
  {db-pre :domino.core/db event-context :domino.core/event-context :as ctx-pre}
  user-changes
  on-success
  on-fail)

transaction-state-keys clj/s

trigger-effects clj/s

(trigger-effects ctx triggers)

trigger-effects-async clj/s

(trigger-effects-async ctx triggers on-success on-fail)

trigger-output-effects! clj/s

(trigger-output-effects! ctx)

update-rx clj/s

(update-rx ctx)

valid-change? clj/s

(valid-change? change)

walk-model clj/s

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