@contexture/client
v2.48.0
Published
The Contexture (aka ContextTree) Client
Downloads
2
Readme
@contexture/client
The Contexture (aka ContextTree) Client
Overview
This library manages the state of a contexture tree to automatically run only the optimal minimal amount of searches possible.
In general, you perform actions
which dispatch
one or more events to an instantiated client, and it reacts by intelligently running searches as needed.
Helpful Mental Models
To help people grok the purpose of the this library, this section attempts to explain in terms of mental models that developers are likely to have seen before.
Redux
You can think of the client like redux with prebuilt actions and reducers that are async and run searches. Of course, astute readers will realize that model breaks down because a reducer that performs side effects and doesn't return new state isn't a reducer at all.
Pub/Sub
You can think of the client as a pub/sub system with prebuilt subscribers that can handle specific events. dispatch
is like publish with the internal process/reactor functions acting as subscribers.
Feature Highlights
- Updates individual nodes independently
- Updates only the most minimal set of nodes possible in response to changes
- Powered by reactors (only/others/all, field/join change, item add/remove) which account for and/or/not relationship
- Per node Pause/Resume
- Keeps track of if it missed updates, allowing it to know if it needs to update on resume or not
- Per node async validation
- Node types can implement a function to have a node instance pass (return true), be ignored for the search (return false), or block the search (throw)
- Per Node Loading Indicators
- Intelligent Search Debouncing (global debounce and optional per node pausing until results come back)
- Dropping intermediate (stale) responses
- Error handling
API
Instantiation
The root function takes two parameters, config
and actual tree
instance. It's curried, so you can call it like this:
ContextureClient({ ...config }, tree)
or
ContextureClient({ ...config })(tree)
if you want to pre apply it with config.
Config
The following config options are available:
| Name | Type | Default | Description |
| ----------------- | ------------------------------ | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| service | function | n/a | Required Async function to actually get service results (from the contexture core). An exception will be thrown if this is not passed in. |
| types | ClientTypeSpec | exampleTypes | Configuration of available types (documented below) |
| debounce | number | 1 | How many milliseconds to globally debounce search. Does not apply when disableAutoUpdates
is true. |
| onChange | (node, changes) => {} | _.noop | A hook to capture when the client changes any property on a node. Can be modified at run time by reassigning the property on a tree instance. Generally only for internal use - if you're looking for this, you probably want watchNode
|
| onResult | (path, response, target) => {} | _.noop | A hook to capture when the client updates a node with results from the server. Can be modified at run time by reassigning the property on a tree instance. |
| debug | boolean | false | Debug mode will log all dispatched events and generally help debugging |
| extend | function | F.extendOn | Used to mutate nodes internally |
| initObject | function | _.identity | Called on the tree (and the "TreeInstance" return value of the client) at initialization and on payloads before add. With mobx
, this would be observable
|
| snapshot | function | _.cloneDeep | Used to take snapshots |
| disableAutoUpdate | boolean | false | When it is true
will trigger target node updates immediately and will disable triggering automatic debounced updates at the end of dispatches. This is useful for a search button use case, similar to pausing the entire tree but always allowing through specific changes. This is typically used with the triggerUpdate
action to kick off a dispatch that will update everything markedForUpdate
. Can be changed at run time. |
Client Types
Available types are passed in as config.
This is the general structure:
{
TypeName: {
init: (node, extend) => {
// Do stuff like extend the node with some default properties
},
defaults: {...} // sugar over simply calling extend(node, {...}) in init
validate: async node => true || false || throw Exception()
reactors: {
fieldName: 'reactor',
field2...
},
// When marked for update by a dispatch to a different node
onUpdateByOthers: (node, extend) => { }
},
Type2....
}
When picking field reactors, you should use the others
reactor for things that are used for filtering (formerly data
properties), and self
for things that are only used to determine that node's context result (formerly config
properties).
NOTE There are a few reserved words you can't use for type properties:
| Name | Type | Notes |
| ---------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| path | [string]
| The array of keys from the root to get to this node |
| markedForUpdate | bool
| True when a node will be updated but the debonce time has not fully elapsed. |
| updating | bool
| True when a node is waiting for a service call (after debounce has elasped) |
| paused | bool
| Tracks whether a node is paused
, which prevents it from requesting updates from the service |
| missedUpdate | bool
| Tracks when nodes would have asked for updates but didn't because they were paused |
| hasValue | bool
| Tracks when a node passed validate
, which is used to determine if it participates in the search |
| lastUpdateTime | timestamp
| Last time this node was updated with results from the service |
| context | object
| Object which holds the contextual results from the server |
| type | string
| Represents the contexture node type |
| key | string
| Uniquely identifies this node in the tree, used to match results |
| updatingPromise | Promise
| Resolves when the node is done updating, and is reset as a new pending promise when markedForUpdate - be careful if relying on this as the promise property is replaced with a new value whenever it's marked for update. |
| updatingDeferred | Futil Deferred
| Interally used to resolve the updatingPromise |
Client Type Definition Config
| Name | Type | Notes |
| ------------------ | -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| init | (node, extend) => {}
| Called when a node is added and when the tree is first initialized. Can be used to do stuff like extend the node with some default properties. |
| defaults | object
| Sugar over simply calling extend(node, {...}) in init |
| validate | async node => true/false/throw Exception()
| An async function that will block updates until it resolves. Return true to let the node participate in the search, false for it to be excluded, or throw to block the search completely. This can be used to block waiting for things like an API service that gets a value. |
| reactors | object
| An object of field names -> reactor names, primarily for use in mutate
|
| subquery.getValues | (sourceNode) => inputValues
| See subquery section below |
| subQuery.useValues | (values, targetNode) => valuesToMutate
| See subquery section below |
| onUpdateByOthers | (node, extend) => {}
| Called when a node is markedForUpdate by an event dispatched to a different node, which should generically capture all events where something caused the relevant filters to change and exclude anything that only affects itself. This is typically used to do things like reset paging since that should be reset when relevant filters change. |
| autoKey | (node, extend) => string
| Called when a node without a key
property is initialized, through add
or during tree initialization. To ensure unique paths, autogenerated keys are automatically deduplicated against the keys of any sibling nodes. Setting this property on a type will override the default autokey function, F.compactJoin('-', [x.field, x.type])
. |
| onDispatch | (event, extend) = > {}
| Called when dispatching and event to a target node that matches the type. event
is the dispatched event payload, typically including node
as a property. |
Run Time
The following methods are exposed on an instantiated client:
| Name | Signature | Description |
| ------------------- | ------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| dispatch | async event -> await searchCompleted
| A lower level, core method of interaction (called automatically by the actions above). You can await this for when updates settle and relevant searches are completed. |
| getNode | [path] -> node
| Lookup a node by a path (array of keys). |
| serialize | () => tree
| Returns a snapshot of the tree without any of the temporary state like updating flags. |
| lens | (path, prop) -> ({ get, set })
| Given a path and a property, returns a lens that provides a getter and a setter for the provided property on the provided path. The setter function does a mutate
. |
| tree | tree | A reference to the internal tree. If you mutate this, you should dispatch an appropriate event. |
| addActions | (({ getNode, flat, dispatch, snapshot, extend, types, initNode }) => {actionsMethods} ) => null
| Experimental A method for extending the client with new actions on a per instance basis. You pass in a function which takes an object containing internal helpers and returns an object with actions that get extended onto the tree instance. |
| addReactors | (() => {customReactors}) => null
| Experimental A method for adding new reactors on a per instance basis. You pass in a function which returns an object of new reactors to support ({reactorName: reactorFunction}
). Reactors are passed (parent, node, event, reactor, types, lookup)
and are expected to return an array of affected nodes. |
| subquery | (targetPath, sourceTree, sourcePath, mapSubqueryValues?) => {}
| Sets up a subquery, using the types passed in to the client and assuming this tree instance is the target tree. For more info, see the subquery section below. |
| isPausedNested | path -> bool
| Returns a bool for whether the node at the path and all of its children are paused. |
| processResponseNode | (path, node) => {}
| Used to process intermediate partial results from the server |
| watchNode | (path, watcherFn, [keys]) => {}
| Runs watcherFn
any time the node at path
is updated, optionally restricted to the array of keys passed in. watcherFn
is called with (node, delta)
which is a reference to the target node and the payload to update it with. Keys may be nested (e.g. context.something
). Keys are not cloned, so you can retain a reference and mutate the keys array to change what's being observed at runtime. Useful for implementing observability, e.g. a react hook. |
Actions
Client methods that mutate or otherwise act on nodes are known as actions. You can await these for when updates settle and relevant searches are completed. Conventionally, actions take a node path as their first parameter.
Note that it's also possible to add custom actions to a client instance through the addActions
method (see the table above for more details).
| Name | Signature | Description |
| ------------- | ----------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| add | async (path, newNode, {index}) -> await searchCompleted
| Adds a node to the tree as a child of the specified path. You can optionally pass an options object as the third param to specify the index where to add the node. The node can be a group with children. |
| remove | async path -> await searchCompleted
| Removes a node at the specified path. Will also remove children of the target node. |
| mutate | async (path, deltas) -> await searchCompleted
| Mutates the node at the given path with the new values. Note that this does not automatically change the paused
flag. This is by design since you should be able to mutate paused nodes. |
| triggerUpdate | async () -> await searchCompleted
| Will trigger an update with a none
reactor, updating only nodes that are already marked for update. This is useful when disableAutoUpdate
is set to true. |
| clear | async path -> await searchCompleted
| Resets the node's values to those given on the node type's defaults
(except field
) |
| replace | async (path, newNodeOrTransform) -> await searchCompleted
| Replaces the node at the given path with a new node. Accepts either a node object or a node -> newNode
transform function as its second argument. If a function is given, it is called on the node at path
, and the result is then used in replace
. |
| wrapInGroup | async (path, newNode) -> await searchCompleted
| Wraps the node at the provided path in a group described by newNode
. The node will be replaced it on its parent's children unless it is root node (with a nul parent). If the node has no parent, it will be done in place by mutating the node into the group described by newNode
with the original node as it's only child. |
| move | async (path, { path, index }) -> await searchCompleted
| Moves the node at the provided path (first argument) to the target location provided in the second parameter. If the target path is not specified, it will default to the current node's group. If the target index isn't provided, it will default to moving to the end of the target group. Useful for drag and drop query builder interfaces that let you move nodes around in and between groups. |
| pauseNested | async path -> await searchCompleted
| Recursively set paused to true for the node at the path and all its children. |
| unpauseNested | async path -> await searchCompleted
| Recursively set paused to false for the node at the path and all its children. |
Node Run Time
The following methods can be added to individual nodes (just set them on the object returned by getNode)
| Name | Signature | Description |
| --------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| onMarkForUpdate | async () => {}
| Called when a node is markedForUpdate (post validate), and will block the search until it resolves. Used internally by subquery. |
| afterSearch | async () => {}
| Called on nodes that were marked for update after the the search finishes - kind of like a per-node onResult, but will block the dispatch until it resolves (useful for holding up dispatches for side effects that an application might want to have happen after a search). Used internally by subquery. |
| validate | async () => {}
| A per-node version of validate which will override the type specific validation method. |
Top Level Exports
A number of utilities are now exposed as top level exports. You can import them like:
import { utilName } from '@contexture/client'
| Name | Description |
| -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Tree | A futil tree
api pre applied with the right traversals, etc for working with contexture trees (e.g. Tree.walk) |
| encode
| The futil encoder method used for the internal flat
tree. Converts a path array to a flat tree key. Currently a slashEncoder. |
| decode
| The futil decoder method used for the internal flat
tree. Converts a flat tree key to a path array. Currently a slashEncoder. |
| hasContext
| An internal utility that determines if a node has a context. Used primarily in custom reactors to help figure out if a node needs updating. |
| hasValue
| An internal utility that checks if a node has a value and isn't in an error state. Used primarily in custom reactors to help figure out if other nodes would be affected by an event. |
| exampleTypes
| A set of example types. This will likely be split out in a future version to its own repo. |
| mockService
| Useful for mocking services during testing. Takes a config object of logInput, logOutput, and a mocks function which will should return results for a node as input (defaults to fixed results by type) and returns a function for use as a service
for a @contexture/client instance. |
| subquery
| A tool for creating a subquery. See the section below. |
Subquery
A subquery (in @contexture/client) is about taking the output of one search and making it the input for another search. This is an in memory, cross-database, "select in" join on sources that don't need to be relational.
This works by providing a source node from which to get values, and a target to use those values. Logic on how to get and use those values are defined in the client type definitions.
The client exposes a method to create subqueries between two trees as a top level export, with this signature:
(types, targetTree, targetPath, sourceTree, sourcePath, mapSubqueryValues?)
It takes types
(to lookup type specific logic), the tree and path of the source node, and then the tree and path of the target node.
Lastly, it can optionally take a function to override the type logic completely.
Client types need to implement these methods to be used in a subquery if mapSubqueryValues is not provided:
| Function Name | Signature | Explanation |
| -------------------- | -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| subquery.getValues
| (sourceNode) => inputValues | Allows a type to be a source node. Returns a list of values (typically an array) from new results for a node of this type. |
| subQuery.useValues
| (values, targetNode) => valuesToMutate | Allows a type to be a target node. Returns a changeset that can be passed to mutate
from a list of a values list (the output of a subquery.getValues call) for a node of this type. |
Here's an example implementation, using the facet
example type:
{
facet: {
subQuery: {
useValues: x => ({ values: x }),
getValues: x => _.map('name', x.context.options)
},
//...
}
}
If you pass mapSubqueryValues
as the last parameter, you can ignore the types
parameter. It's signature is (sourceNode, targetNode, types) => deltasForTargetNodeMutate
.
Loading Indicators
A change to the source node in a subquery will immediately mark the target node as marked for update, but will not execute it's search until after the source node has results and the debounce time passes.
Since target nodes are immediately marked for update when source nodes are, this eliminates the "double loading spinner" issue we've seen in other implementations.
Dispatches that result in subquery source nodes being updated will await the updates of the target nodes in their afterSearch
methods - which means you can get a promise for when the whole thing finishes updating.
Extending the Client
The client can be enhanced with new types, actions, and reactors.
- Types are the most common form of new functionality to be added and are paired with a type implementation for the contexture for a given provider.
- Actions represent a generic type of change to the tree. Custom actions are a great way to experiment with new functionality before adding it to the core and can directly access a lot of typically inaccessible internals like the
flat
tree (which you shouldn't need for normal use). Actions are added on a per instance basis usingtree.addActions
. - Reactors can be added to dispatch new event types. Custom reactors are a way to experiment with new functionality before adding it to the core. Reactors are added on a per instance basis using
tree.addReactors
.
Improvements
For those familiar with the previous client implementation (DataContext
/ContextGroup
), this client has a lot of design improvements:
- The update logic now accounts for the join relationship, making it even more precise about when to run searches
- Dispatch (and action methods) return a promise for when it resolves despite debounce, instead of relying on subscribing to when an
updating
observable becomes falsey. - Much more memory efficient - functional instead of local function copies
- Instant traversals due to flat tree in parallel with nested
- Redux-y API
Implementation Details
:construction: More Details Coming Soon. :construction:
Process Algorithm
- An action method is called at the top level which:
- Interally mutates the tree
- Makes one or more calls to
dispatch
with relevant event data
- For each dispatched event:
- Validate the entire tree (an async operation)
- Bubble up the tree from the affected node up to the root, and for each node in the path:
- Determine affected nodes by calling the reactor for the current event type
- Mark each affected node for update, or if it is currently paused, mark that it missed updates
- Trigger an update (which is debounced so it does not run right away)
- When the debounce elapses, an update is triggered:
- Check if the update should be blocked
- There may be no affected nodes
- Some nodes might have erros on validation
- Prepare for update - on each node that's markedForUpdate:
- Set the lastUpdateTime to now (to enable dropping stale results later in this process)
- Set
updating
to true
- Serialize the search and omit all temporary state except lastUpdateTime (which the sever will effectively echo back).
- Execute an actual contexture search
- For each node in the response:
- If the path isn't found in the current tree, ignore it
- If the response is empty, ignore it
- If the response has a lastUpdateTime earlier than the node in the current tree, ignore it (because it's stale)
- If not ignoring the update, mutate the node with the result and set
updating
to false
- Check if the update should be blocked
- After all of this, the promise for the action/dispatch resolves (so you can await the entire process)
Flat Trees
The client maintains a flat tree in addition to the actual tree, which is an object mapped using flattenTree
from futil-js
.
The keys are the array paths encoded as a string, currently using a slashEncoder.
This allows path lookups to perform in constant time at O(1)
, which drastically speeds up some of the internal tree operations.
The paths are also stamped on individual nodes for convenience as performing an action on a node requires knowing its path.
Initialization
On instantiation, the client creates a flat tree representation of the tree and stamps the paths on the nodes.